澳门网络娱乐游戏平台-澳门电子游戏娱乐网址-官方直营

React组件企划

React组件兼顾

函数式编制程序,对应的是声明式编制程序,评释式编制程序的本色的lambda验算(是二个匿名函数,即未有函数名的函数。Lambda表明式能够代表闭包)

官方赌钱网上平台 1

组件分类

React元素

react.jpg

展现组件和容器组件

展示组件 容器组件
关注事物的展示 关注事物如何工作
可能包含展示和容器组件,并且一般会有DOM标签和css样式 可能包含展示和容器组件,并且不会有DOM标签和css样式
常常允许通过this.props.children传递 提供数据和行为给容器组件或者展示组件
对第三方没有任何依赖,比如store 或者 flux action 调用flux action 并且提供他们的回调给展示组件
不要指定数据如何加载和变化 作为数据源,通常采用较高阶的组件,而不是自己写,比如React Redux的connect(), Relay的createContainer(), Flux Utils的Container.create()
仅通过属性获取数据和回调
很少有自己的状态,即使有,也是自己的UI状态
除非他们需要的自己的状态,生命周期,或性能优化才会被写为功能组件

上边是多个大概会常常写的零零件,商议列表组件,数据人机联作和展现都放到了叁个组件里面。

// CommentList.js
class CommentList extends React.Component {
  constructor() {
    super();
    this.state = { comments: [] }
  }
  componentDidMount() {
    $.ajax({
      url: "/my-comments.json",
      dataType: 'json',
      success: function(comments) {
        this.setState({comments: comments});
      }.bind(this)
    });
  }
  render() {
    return <ul> {this.state.comments.map(renderComment)} </ul>;
  }
  renderComment({body, author}) {
    return <li>{body}—{author}</li>;
  }
}

大家对地点的零器件进行拆分,把她拆分成容器组件 CommentListContainer.js 和出示组件 CommentList

// CommentListContainer.js
class CommentListContainer extends React.Component {
  constructor() {
    super();
    this.state = { comments: [] }
  }
  componentDidMount() {
    $.ajax({
      url: "/my-comments.json",
      dataType: 'json',
      success: function(comments) {
        this.setState({comments: comments});
      }.bind(this)
    });
  }
  render() {
    return <CommentList comments={this.state.comments} />;
  }
}


// CommentList.js
class CommentList extends React.Component {
  constructor(props) {
    super(props);
  }
  render() { 
    return <ul> {this.props.comments.map(renderComment)} </ul>;
  }
  renderComment({body, author}) {
    return <li>{body}—{author}</li>;
  }
}

优势:

  • 展现和容器越来越好的分别,越来越好的接头应用程序和UI
  • 重用性高,显示组件能够用来七个不等的state数据源
  • 来得组件正是您的调色板,能够把他们松开单独的页面,在不影响应用程序的事态下,让设计员调解UI
  • 反逼你分手标签,达到越来越高的可用性

React成分使用JSON格式的代码:

const DeleteAccount = () => ({
    type: 'div',
    props: {
        children: [
            {
                type: 'p',
                props: {
                    children: 'Are you sure?'
                }
            },
            {
                type: DangerButton,
                props: {
                    children: 'Confirm'
                }
            },
            {
                type:Button,
                props: {
                    children: 'Cancel'
                }
            }
        ]
    }
})

React.createElement表示的代码:

var DeleteAccount = function() {
    return React.createElment(
        'div',
        null,
        React.createElment(
            'p',
            null,
            'Are you sure?'
        ),
        React.createElment(
            DangerButton,
            null,
            'Confirm',
        ),
        React.createElment(
            Button,
            { color: 'blue' },
            'Cancel'
        )
    )
}
说在前面

关于 react 的总括过去八个月就一向碎碎念着要搞起来,各(wo)种(tai)原(lan)因(le),对的就是小编太懒了。近来去体格检查的时候,查体格检查报告时都顶着各类思想压力啊, 和杜撰中的相符各个专门的学业病种种肉体亚健康呢。 所以未来尽心竭力早睡百折不回早起了,然后呢,起得已经有的时候间做简单计算了。心心念的东西重新拿了起来了。希望以此总括回顾能对你的平凡支出依旧跳槽面试有帮带哪怕独有那么一小点,反正对自己扶植是挺大,温故而知新嘛!!!

废话说了一群, 这么些计算恐怕大概恐怕会以问答的款式计算
期望你能挨个击破,像闯关卡相似贰个叁个过!开首吧 !Let's go!

有情况组件和无状态组件

上面是二个最轻便易行的无状态组件的例证:

function HelloComponent(props, /* context */) {
  return <div>Hello {props.name}</div>
}
ReactDOM.render(<HelloComponent name="Sebastian" />, mountNode)

能够观看,原来要求写“类”定义(React.createClass 或者 class YourComponent extends React.Component)来创设自身组件的定义(有情状组件),现在被轻巧成了只写叁个 render 函数。更值得意气风发提的是,由于单独是二个无状态函数,React 在渲染的时候也省掉了将“组件类” 实例化的长河。

结合 ES6 的解构赋值,能够让代码更洗练。举例上面那些 Input 组件:

function Input({ label, name, value, ...props }, { defaultTheme }) {
  const { theme, autoFocus, ...rootProps } = props
  return (
    <label
      htmlFor={name}
      children={label || defaultLabel}
      {...rootProps}
    >
    <input
      name={name}
      type="text"
      value={value || ''}
      theme={theme || defaultTheme}
      {...props}
    />
  )}
Input.contextTypes = {defaultTheme: React.PropTypes.object};

无状态组件不像上述二种办法在调用时会创立新实例,它创建时一向维持了叁个实例,制止了不供给的检查和内部存储器分配,做到了里面优化。

无状态组件不扶持 "ref"

组件

构件封装的时候,组件的几项专门的学问标准:

  • 主旨的封装性
  • 轻便的扬言周期展现
  • 眼看的数目流动

Web Component 的4个组成都部队分:

  • HTML Templates定义了模版的概念
  • 官方赌钱网上平台 ,Custom Elements定义了组件的表现方式
  • Shadow DOM定义了组件的成效域范围,能够饱含样式
  • HTML Imports提议了新的引进情势
![](https://upload-images.jianshu.io/upload_images/4345168-52d883f57d101525.png)

Web Components组成

React组件的创设:
Web Component通过自定义元素的方法得以实现组件化,而React的庐山面目目正是关爱成分的结合,React组件即为组件成分。组件成分被描述成纯粹的JSON对象。
React组件基本上由3个部分构成 -- 属性(props),状态(state)以致生命周期

官方赌钱网上平台 2

React组件的咬合

React全体组件世袭自顶层类 React.Component。它的定义格外简短,只是最早化了 React.Component方法,注明了props、context、refs等,并在原型上定义了setState和forceUpdate方法。内部最先化的扬言周期方法与createClass方法运用的是同贰个艺术创设的。那类组件会成立实例对象。

无状态组件:使用无状态函数营造的构件,只传入props和context八个参数,子虚乌有state,未有生命周期方法。它创造时平昔维持了多少个实例,幸免了不必要的自己商酌和内部存款和储蓄器分配,做到了在那之中优化

【1】react component有两种写法?分别是如何?

① 函数式定义的无状态组件(Stateless Functional卡塔尔

  • 品质更飞快、代码更简单
  • 平素不 state,也正是无状态
  • 无需管住/维护 组件的生命周期
  • 纯函数,相符的 props 会获得平等的UI渲染结果
    function List (props) {
        return <div>我是一个函数式定义的react组件</div>
    }

ES5方式 React.createClass 定义的组件(该情势已经被丢掉,官方文书档案推荐是用①和③卡塔尔(قطر‎
③ ES6 方式定义的组件(Class Components卡塔尔(英语:State of Qatar)

    class List extends React.Component {
        render() {
            return <div>我是一个es6方式定义的react组件</div>
        }
    }

合丹麦语档写的可能颇有神秘感的,先告知我们①和③方式在 UI 渲染效果是一毛同样的,但是'Classes have some additional features...' Class 这种方法比 Functional 这种办法多了些不均等的地点。那么难题来了。多了何等不平等的吧? 不雷同的地点你可能也发觉了,有无 state有无生命周期...等

高阶组件

高阶组件通过函数和闭包,改造本来就有组件的展现,本质上便是 Decorator 模式在 React 的后生可畏种完结。

当写着写着无状态组件的时候,有一天猛然开采需求状态管理了,那么没有要求透顶返工:卡塔尔(قطر‎
每每大家须要状态的时候,那些要求是足以援引的。

高阶组件加无状态组件,则大大提升了全副代码的可测量试验性和可维护性。同期不断“诱使”大家写出组合性更加好的代码。

state

注意:setState是三个异步方法,二个生命周期内部存款和储蓄器有的setState方法会合并操作。

智能组件(smart Component):内部(State)更新数据,调控组件渲染
玩偶组件(dumb COmponent):外界(props)更新数据,调整组件渲染

【2】那如曾几何时候该用 Stateless Functional 什么日期用 Class 呢?

推荐介绍使用 Functional,能用 Functional 就用 Functional,就酱。
多说一句。Class 是用来创建包罗境况生命周期客商人机联作的复杂组件,而当组件只是用来纯展示或者 props 传递渲染时(显示性卡塔尔(英语:State of Qatar),不说任何别的话请用 Stateless Functional 来飞速创立组件。

高阶函数

function welcome() {
    let username = localStorage.getItem('username');
    console.log('welcome ' + username);
}

function goodbey() {
    let username = localStorage.getItem('username');
    console.log('goodbey ' + username);
}

welcome();
goodbey();

小编们开采五个函数有一句代码是毫无二致的,这叫冗余唉。(平日只怕会有一大段代码的冗余卡塔尔(قطر‎。

下边大家要写一个在那之中等学园函授数,读取username,他来担任把username传递给八个函数。

function welcome(username) {
    console.log('welcome ' + username);
}

function goodbey(username) {
    console.log('goodbey ' + username);
}

function wrapWithUsername(wrappedFunc) {
    let newFunc = () => {
        let username = localStorage.getItem('username');
        wrappedFunc(username);
    };
    return newFunc;
}

welcome = wrapWithUsername(welcome);
goodbey = wrapWithUsername(goodbey);

welcome();
goodbey();

好了,大家个中的 wrapWithUsername 函数便是三个“高阶函数”。
她做了哪些?他帮大家管理了 username,传递给目的函数。大家调用最后的函数 welcome的时候,根本并不是关怀 username是怎么来的。

props

props是properties的缩写。props是React用来组件之间相互联系的生机勃勃种机制,通俗的说有如方法的参数相近。

  • 子组件prop
    在React中有四个至关心注重要且内置的prop--children,它象征组件的子组件集结。

  • 组件props
    在组件的prop中某叁天性质,我们传入节点,然后渲染那个节点,和 children 肖似

  • 用function prop与父组件通讯

  • propTypes
    用于规范props的花色与必需的情事。

【3】无状态组件(Stateless Functional卡塔尔(قطر‎有哪些优弱点
  • 优点
  1. 语法/代码尤其简明
  2. 占用内部存款和储蓄器小(未有 props 等个性), 第一遍 render 品质越来越好
  3. 无需管住/维护组件的生命周期
  4. 纯函数,肖似的 props 会获得平等的 UI 渲染结果
  5. 单元测验更易于实行。因为逻辑都被移出了 view 层,所以单元测验时无需渲染任王大帅西,能够小心于单个逻辑。
  • 缺点
  1. 无生命周期函数。对于二个函数来讲应该是谈不上生命周期。当然了,我们实际上能够采用高阶组件去落实生命周期。
  2. 没有 this。在Stateless中 this 是 undefined 。

依此类推的高阶组件

上边是四个冗余的零件。

import React, {Component} from 'react'

class Welcome extends Component {
    constructor(props) {
        super(props);
        this.state = {
            username: ''
        }
    }

    componentWillMount() {
        let username = localStorage.getItem('username');
        this.setState({
            username: username
        })
    }

    render() {
        return (
            <div>welcome {this.state.username}</div>
        )
    }
}

export default Welcome;

import React, {Component} from 'react'

class Goodbye extends Component {
    constructor(props) {
        super(props);
        this.state = {
            username: ''
        }
    }

    componentWillMount() {
        let username = localStorage.getItem('username');
        this.setState({
            username: username
        })
    }

    render() {
        return (
            <div>goodbye {this.state.username}</div>
        )
    }
}

export default Goodbye;

笔者们能够透过刚刚高阶函数的考虑来创造叁在那之中级组件,也等于我们说的高阶组件。

import React, {Component} from 'react'

export default (WrappedComponent) => {
    class NewComponent extends Component {
        constructor() {
            super();
            this.state = {
                username: ''
            }
        }

        componentWillMount() {
            let username = localStorage.getItem('username');
            this.setState({
                username: username
            })
        }

        render() {
            return <WrappedComponent username={this.state.username}/>
        }
    }

    return NewComponent
}

import React, {Component} from 'react';
import wrapWithUsername from 'wrapWithUsername';

class Welcome extends Component {

    render() {
        return (
            <div>welcome {this.props.username}</div>
        )
    }
}

Welcome = wrapWithUsername(Welcome);

export default Welcome;

import React, {Component} from 'react';
import wrapWithUsername from 'wrapWithUsername';

class Goodbye extends Component {

    render() {
        return (
            <div>goodbye {this.props.username}</div>
        )
    }
}

Goodbye = wrapWithUsername(Goodbye);

export default Goodbye;

看看没有,高阶组件正是把 username 通过 props 传递给指标组件了。目标组件只管从 props其间拿来用就好了。

为了代码的复用性,大家应有尽量减少代码的冗余。

  1. 领取分享的state,假使有五个构件都亟待加载相符的数目,那么她们会有生机勃勃致的 componentDidMount 函数。
  2. 寻找双重的代码,每一种组件中constructor 和 componentDidMount都干着同等的事体,其余,在数据拉取时都会显得Loading... 文案,那么大家应当思量如何运用高阶组件来领取那一个措施。
  3. 搬迁重复的代码到高阶组件
  4. 卷入组件,并且选拔props替换state
  5. 尽也许地简化

生命周期

分为两类:

  • 当组件在挂载或卸载时
  • 当组件选拔新的多寡时,即组件更新时
【4】React.Component 绑定方法的三种格局?
    //第一种方法:构造函数中绑定

    class List extends React.Component {
        constructor(props) {
            super(props)
            this.onClickList = this.onClickList.bind(this)
        }

        onClickList() {
            console.log('我被点了')
        }

        render() {
            return <div onClick={this.onClickList}>点我点我点我</div>
        }

    }

    //第二种方法: 在render()行内事件使用bind来绑定

    class List extends React.Component {

        onClickList() {
            console.log('我被点了')
        }

        render() {
            return <div onClick={this.onClickList.bind(this)}>点我点我点我</div>
        }

    }

    //第三种方法: 使用箭头函数 => 

    class List extends React.Component {

        onClickList = () => {
            console.log('我被点了')
        }

        render() {
            return <div onClick={this.onClickList}>点我点我点我</div>
        }

    }

    //第四种,当然,你要在render()行内使用箭头函数也行

    class List extends React.Component {

        onClickList() {
            console.log('我被点了')
        }

        render() {
            return <div onClick={() => this.onClickList()}>点我点我点我</div>
        }

    }

自个儿平日开支都相比心仪用箭头函数的不二秘籍,就因为偷懒,代码量比第大器晚成种少。当然,官方说在 render 中开创函数(第二,和第各类卡塔尔或许会有品质难题。但一再需求传递参数或者回调时,都得用到。譬如:

    <button onClick={() => this.handleClick(id)} />
    <button onClick={this.handleClick.bind(this, id)} />

组件开拓为主思维

组件的挂载,那么些进度首要做组件状态早先化

// 推荐使用这个例子作为模板写初始化组件
 class App extends Component { 
    // props类型检查
    static propTypes = {
      // ... 
    };
    // 默认类型
    static defaultProps = {
     // ...
    };
    constructor(props) { super(props);
        this.state = {
           // ...
        }; 
    }
    componentWillMount() { 
        // ...
    }

    componentDidMount() { 
        // ...
    }
    render() {
      return <div>This is a demo.</div>;
    } 
}

propTypes和defaultProps申明成静态属性,意味着从类外面也足以访问他们,例如:App.propTypes和App.defaultProps

【5】智能组件 vs 木偶组件 ? 或许 容器组件 vs 展现组件 ?

Smart 组件 和 Dumb 组件对于开采过 react 项目标相爱的人的话应该不素不相识了。

Dumb 组件,听名字你就通晓这种组件很傻很木,因为木偶组件只关心意气风发件事情就是—— 依照 props 实行渲染。
Smart 组件就很聪明,它非常做多稀有关的逻辑,和各路数据打交道,ajax获取数据,定义好数据操作的连锁函数,然后将这个多少、函数直接传送给现实落成的构件(Dumb 组件卡塔尔(قطر‎就可以。所以依照是或不是必要高度的复用性,把组件划分为 Dumb 和 斯马特组件。

小提醒1:Smart 组件复用性不强以至没有须要复用,Dumb 组件往往是复用性强的,不过Dumb 组件对于 Smart组件的带入性不要太强,因为带领太多逻辑会引致复用性收缩。二者选择,设计组件时供给切磋一下。

小提醒2:Dumb 组件 的子组件也应该是 Dumb 组件。

单效用原则

接收react时,组件或器皿的代码在素有上必须只承当一块UI功效。

零件的卸载

componentWillUnmount
以此艺术中,我们日常会试行一些理清办法,如事件回笼或是消亡电磁打点计时器

有关React生命周期

有关生命周期,面试的时候总中意问点儿相关的,并且想要驾驭旁人写的 react 代码,深入精通 react 生命周期也是很注重的。先不要往下看,闭上眼睛思考看你所驾驭的 react 生命周期有怎么样?

...

...

...

...

...

...

官方赌钱网上平台 3

liftcycle.jpg

ok 你应该想完了哈。是否大概有上边这么一个流程?(图片是卓越的机件挂载图来源于网络卡塔尔(英语:State of Qatar)

react 组件的生命周期方法都足以被分开成三个等级:带头化、挂载阶段(Mounting)、更新阶段(Updating)、卸载阶段(Unmounting)。

接下去就让大家去看看生命周期都有怎么样小知识点。

让组件保持简单

  • 意气风发经组件根本无需状态,那么就利用函数定义的无状态组件。

  • 从品质上的话,函数定义的无状态组件 > ES6 class 定义的构件 > 通过 React.createClass() 定义的构件。

  • 仅传递组件所须要的性质。唯有当属性列表太长时,才使用{...this.props}实行传递。

  • 比如组件里面有太多的论断逻辑(if-else话语)平时意味着这几个组件必要被拆分成越来越细的零部件或模块。

  • 行使显著的命名能够让开辟者理解它的机能,有助于组件复用。

数据更新进程

更新进度指父组件向下传递props或机件本身实行setState方法时发出的生龙活虎多种更新动作。

import React, { Component, PropTypes } from 'react';
class App extends Component {
  componentWillReceiveProps(nextProps) {
    // this.setState({})
  }
shouldComponentUpdate(nextProps, nextState) {
  // return true;
}
  componentWillUpdate(nextProps, nextState) {
    // ...
  }
  componentDidUpdate(prevProps, prevState) {
    // ...
  }
  render() {
    return <div>This is a demo.</div>;
  }
}

若是state更新了,那么会挨个执行shouldComponentUpdate、componentWillUpdate、render和componentDidUpdate

外来组件prop传递步入使组件更新

componentWillReceiveProps(nextProps) {
  if ( 'activeIndex' in nextProps ) {
    this.setState({
      activeIndex: nextProps.activeIndex
    })
  }
}
【6】Mounting(挂载卡塔尔(英语:State of Qatar) -- 下边那几个办法将会在 component 实例被创建和插入到DOM后调用。
  • constructor()
  • componentWillMount()
  • render()
  • componentDidMount()

基本准则

  • shouldComponentUpdate中幸免不供给的检查.

  • 不遗余力采纳不可变数据类型(Immutable).

  • 编纂针对产品意况的包装配置(Production Build).

  • 通过Chrome Timeline来记录组件所消耗的能源.

  • componentWillMount或者componentDidMount当中通过setTimeOut或者requestAnimationFram来推迟施行那个须要大批量测算的任务.

总体流程

官方赌钱网上平台 4

React阐明周期全部流程图

官方赌钱网上平台 5

使用ES6 classes与createClass营造组件方法的异同

【7】Updating -- props 恐怕 state 的改变都会形成立异。上边那些方法会在 component 重新渲染时调用。
  • componentWillReceiveProps()
  • shouldComponentUpdate()
  • componentWillUpdate()
  • render()
  • componentDidUpdate()

组件开辟技艺

React与DOM

【8】Unmounting -- 该措施将会在 component 从DOM中移除时调用。
  • componentWillUnmount()

form表单里的受控组件和不受控组件

ReactDOM

ReactDOM中的API很少,只有findDOMNode、unmountComponentAtNode和render

  1. findDOMNode
    DOM真正被增加到HTML中的生命周期方法是componentDidMount和componentDidUpdate方法。ReactDOM提供findDOMNode:DOMElement findDOMNode(ReactComponent component卡塔尔国,假诺当前组件加载完时获取当前DOM,则足以接收findDOMNode
import React, { Component } from 'react'; 
import ReactDOM from 'react-dom';
class App extends Component { 
  componentDidMount() {
     // this 为当前组件的实例
      const dom = ReactDOM.findDOMNode(this); 
  }
  render() {} 
}
  1. render
ReactComponent render( 
  ReactElement element, 
  DOMElement container, 
  [function callback]
)

该格局把成分挂在到container中,并重临element的实例(即refs引用)。假诺是无状态组件,render会再次来到null。组件挂载达成时,callback就能够被调用。
与 render 相反,React 还提供了三个超少使用的 unmountComponentAtNode 方法来开展
卸载操作

接下去差不离的牵线一下多少个生命周期。

受控组件

在超过51%情形下,大家推荐使用受控组件来兑现表单。在受控组件中,表单数据由 React 组件担当管理。下面是一个独立的受控创设。

class NameForm extends React.Component {
  constructor(props) {
    super(props);
    this.state = {value: ''};

    this.handleChange = this.handleChange.bind(this);
    this.handleSubmit = this.handleSubmit.bind(this);
  }

  handleChange(event) {
    this.setState({value: event.target.value});
  }

  handleSubmit(event) {
    alert('A name was submitted: ' + this.state.value);
    event.preventDefault();
  }

  render() {
    return (
      <form onSubmit={this.handleSubmit}>
        <label>
          <input type="text" value={this.state.value} onChange={this.handleChange} />
        </label>
        <input type="submit" value="Submit" />
      </form>
    );
  }
}

设置表单成分的value品质之后,其出示值将由this.state.value决定,以满足React意况的相符数据思想。每一趟键盘敲击之后会实践handleChange方法以立异React意况,展现值也将随着客户的输入更改。

对于受控组件来讲,每壹回 state(状态卡塔尔变化都会伴有相关联的管理函数。那使得能够直接改进或证实客商的输入和付出表单。

refs

ref -> reference
ref再次回到多少个实例对象,也足以是一个回调函数,focus的高超完成,就是应用回调函数

import React, { Component } from 'react';
class App extends Component { 
    constructor(props){
        super(props);
        this.handleClick = this.handleClick.bind(this); 
    }

  handleClick() {
    if (this.myTextInput !== null) {
        this.myTextInput.focus(); }
    }
    render() { 
        return (
            <div>
                <input type="text" ref={(ref) => this.myTextInput = ref} /> <input
                type="button"
                value="Focus the text input" onClick={this.handleClick}
            /> </div>
       ); 
【9】1. componentWillMount

componentWillMout(卡塔尔国 是在组件挂载(mount卡塔尔(قطر‎从前被调用.
componentWillMount(卡塔尔国是天下无双四个在服务器端渲染(ssr卡塔尔调用的生命周期钩子

关于 setState 在 componentWillMount 使用:可以选拔。因为它是 render 方法以前被调用,因而 setState 也不会招致重绘(re-render卡塔尔国

不受控组件

因为不受控组件的数量来源于是 DOM 成分,当使用不受控组件时相当的轻易完结 React 代码与非 React 代码的购并。固然你期待的是高速支付、无需代码品质,不受控组件能够肯定水准上压缩代码量。不然。你应有利用受控组件。

诚如景色下不受控组件大家使用ref来获取DOM要素举办操作。

class NameForm extends React.Component {
  constructor(props) {
    super(props);
    this.handleSubmit = this.handleSubmit.bind(this);
  }

  handleSubmit(event) {
    alert('A name was submitted: ' + this.input.value);
    event.preventDefault();
  }

  render() {
    return (
      <form onSubmit={this.handleSubmit}>
        <label>
          Name:
          <input type="text" ref={(input) => this.input = input} />
        </label>
        <input type="submit" value="Submit" />
      </form>
    );
  }
}

React之外的DOM操作

DOM操作可以归结为对DOM的增、删、改、查。“查”指的是对DOM属性、样式的查看,比方DOM的职位、宽、高档音讯。借使要调用HTML5 奥迪(Audi卡塔尔(قطر‎o/Video的play方法和input的focus方法,此时智能使用相应的DOM方法来落到实处。
比如Popup等组件

componentDidUpdate(prevProps, prevState) {
  if ( !this.state.isActive  && prevState.isActive ) {
     document.removeEventListener('click', this.hidePopup);
  }

  if( this.state.isActive && !prevState.isActive ) {
    document.addEventListener('click', this.hidePopup)
  }
}

componentWillUnmount() {
  document.removeEventListener('click', this.hidePopup)
}

if( !this.isMounted() ) {
  return false;
}

const node = ReactDOM.findDOMnode(this);
const target = e.target || e.srcElement;
const isInside = node.contains(target);

if ( this.state.isActive && !isInside ) {
  this.setState({
    isActive: false
  })
}

测算DOM的尺码(即地点新闻),提供width和height那样的工具函数

function width(el) {
  const styles = el.ownerDocument.defaultView.getComputedStyle(el, null);
  const width = parseFloat(styles.width.indexOf('px') !== -1 ? styles.width : 0);
  const boxSizing = styles.boxSizing || 'content-box';
  if (boxSizing === 'border-box') {
    return width;
  }
  const borderLeftWidth = parseFloat(styles.borderLeftWidth);
  const borderRightWidth = parseFloat(styles.borderRightWidth);
  const paddingLeft = parseFloat(styles.paddingLeft);
  const paddingRight = parseFloat(styles.paddingRight);
  return width - borderRightWidth - borderLeftWidth - paddingLeft - paddingRight;
}
【10】2. componentDidMount

componentDidMount(卡塔尔(英语:State of Qatar) 在组件挂载之后即刻履行

在此个钩子里适当:

  • ajax 请求
  • 初阶化DOM节点的操作
  • 安装电磁打点计时器 setTimeout 或许 setInterval (温馨提醒,别忘了在 componentWillUnmount 关闭那一个沙漏卡塔尔国

关于 setState 在 componentDidMount 使用: 能够运用。不过平时产生品质难题。当然非要在 render 前获得 DOM 节点的轻重和职位,是能够用的。

片尾曲。面试题:ajax 诉求应该在哪个生命周期?为啥?

本文由澳门网络娱乐游戏平台发布于Web前端,转载请注明出处:React组件企划

相关阅读