日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
在開始React之前，你需要學(xué)好這些JavaScript

我在給別人培訓(xùn) React 的過程中得出這樣的一個結(jié)論：React 完全是關(guān)于 JavaScript 的。而且，有很多材料是關(guān)于 JavaScript 而不是 React。其中大部分是 JavaScript ES6 及其特性和語法，還包括三元運算符、簡化的語法、this 對象、JavaScript 內(nèi)置函數(shù)（map、reduce、filter）或更一般的概念，如可組合性、可重用性、不變性或高階函數(shù)。在剛開始接觸 React 之前，你可能不需要掌握這些基礎(chǔ)知識，但在學(xué)習(xí)或?qū)嵺`過程中肯定需要用到它們。這篇文章列出了大部分有用的 JavaScript 特性，將在你學(xué)習(xí) React 的過程中助你一臂之力。

10年積累的網(wǎng)站設(shè)計、網(wǎng)站制作經(jīng)驗，可以快速應(yīng)對客戶對網(wǎng)站的新想法和需求。提供各種問題對應(yīng)的解決方案。讓選擇我們的客戶得到更好、更有力的網(wǎng)絡(luò)服務(wù)。我雖然不認(rèn)識你，你也不認(rèn)識我。但先網(wǎng)站制作后付款的網(wǎng)站建設(shè)流程，更有威寧免費網(wǎng)站建設(shè)讓你可以放心的選擇與我們合作。

在開始 React 之前先學(xué)習(xí) JavaScript

當(dāng)你開始進(jìn)入 React 的世界，create-react-app（https://github.com/facebook/create-react-app）通常會是你的***個 React 項目。在搭建好項目后，你將看到下面的這個 React 類組件：

 
 
 
    
  
  
  
  1. import React, { Component } from 'react'; 
    2. 
  
  
  
  2. import logo from './logo.svg'; 
    3. 
  
  
  
  3. import './App.css'; 
    4. 
  
  
  
  4. class App extends Component { 
    5. 
  
  
  
  5.   render() { 
    6. 
  
  
  
  6.     return ( 
    7. 
  
  
  
  7.        
    8. 
  
  
  
  8.          
    9. 
  
  
  
  9.            
    10. 
  
  
  
  10.           Welcome to React 
    11. 
  
  
  
  11.          
    12. 
  
  
  
  12.          
    13. 
  
  
  
  13.           To get started, edit src/App.js and save to reload.
    14. 
  
  
  
  14.         
     
    15. 
  
  
  
  15.       
 
  •     ); 
  •   }
  •  } 
  • export default App;

    • React 類組件可能不是***的入手點。新手有許多東西需要消化，不一定與 React 有關(guān)：類語句、類方法和繼承。導(dǎo)入語句也會在學(xué)習(xí) React 時增加額外的復(fù)雜性。盡管主要焦點應(yīng)該放在 JSX（React 的語法）上，但其他的東西也需要解釋一番。這篇文章主要針對 JavaScript，所以請不用太擔(dān)心 React 相關(guān)的內(nèi)容。

    React 和 JavaScript 類

    關(guān)于 React 類組件，需要用到有關(guān) JavaScript 類的先驗知識。JavaScript 類的概念相對較新。之前，只有 JavaScript 的原型鏈可用于實現(xiàn)繼承。JavaScript 類以原型繼承為基礎(chǔ)，讓繼承體系變得更簡單。

    定義 React 組件的一種方法是使用 JavaScript 類。

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

    一個類描述了一個實體，用于創(chuàng)建實體的實例。在使用 new 語句創(chuàng)建類的實例時，會調(diào)用這個類的構(gòu)造函數(shù)。類的屬性通常位于構(gòu)造函數(shù)中。此外，類方法（例如 getName()）用于讀取（或?qū)懭耄嵗臄?shù)據(jù)。類的實例在類中使用 this 對象來表示，但在外部，僅指定給 JavaScript 變量。

    在面向?qū)ο缶幊讨?，類通常用來實現(xiàn)繼承。在 JavaScript 中也一樣，extends 語句可用于讓一個類繼承另一個類。一個子類通過 extends 語句繼承了一個父類的所有功能，還可以添加自己的功能。

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

     基本上，要理解 React 的類組件，知道這些就夠了。JavaScript 類用于定義 React 組件，React 組件繼承了從 React 包導(dǎo)入的 React Component 類的所有功能。

     
 
 
      
  
  
  
    1. import React, { Component } from 'react'; 
      2. 
  
  
  
    2. class App extends Component { 
      3. 
  
  
  
    3.   render() { 
      4. 
  
  
  
    4.     return ( 
      5. 
  
  
  
    5.       
       
      6. 
  
  
  
    6.         
      Welcome to React
       
      7. 
  
  
  
    7.       
     
  •     ); 
  •   } 
  • } 
  • export default App;

    • 這就是為什么 render() 方法在 React 類組件中是必需的：從 React 包導(dǎo)入的 React Component 用它在瀏覽器中顯示某些內(nèi)容。此外，如果不從 React Component 繼承，將無法使用其他生命周期方法（包括 render() 方法）。例如，如果不繼承，那么 componentDidMount() 生命周期方法就不存在，因為現(xiàn)在這個類只是一個普通 JavaScript 類的實例。除了生命周期方法不可用，React 的 API 方法（例如用于本地狀態(tài)管理的 this.setState()）也不可用。

    我們可以通過 JavaScript 類來擴(kuò)展通用類的行為。因此，我們可以引入自己的類方法或?qū)傩浴?/p>

     
 
 
      
  
  
  
    1. import React, { Component } from 'react';
      2. 
  
  
  
    2. 
  
  
  
    3. class App extends Component { 
      4. 
  
  
  
    4.   getGreeting() { 
      5. 
  
  
  
    5.     return 'Welcome to React'; 
      6. 
  
  
  
    6.   } 
      7. 
  
  
  
    7. 
  
  
  
    8.   render() { 
      9. 
  
  
  
    9.     return ( 
      10. 
  
  
  
    10.       
       
      11. 
  
  
  
    11.         
      {this.getGreeting()}
       
      12. 
  
  
  
    12.       
     
  •     ); 
  •   } 
  • } 
  • export default App;

    • 現(xiàn)在你應(yīng)該知道為什么 React 使用 JavaScript 類來定義 React 類組件。當(dāng)你需要訪問 React 的 API（生命周期方法、this.state 和 this.setState()）時，可以使用它們。接下來，你將看到如何以不同的方式定義 React 組件，比如不使用 JavaScript 類，因為有時候你可能不需要使用類方法、生命周期方法或狀態(tài)。

    盡管我們可以在 React 中使用 JavaScript 類繼承，但這對于 React 來說不是一個理想的結(jié)果，因為 React 更傾向于使用組合而不是繼承。因此，你的 React 組件需要擴(kuò)展的唯一類應(yīng)該是 React Component。

    React 中的箭頭函數(shù)

    在給別人培訓(xùn) React 時，我在一開始就向他們解釋 JavaScript 的箭頭函數(shù)。箭頭函數(shù)是 ES6 新增的語言特性之一，讓 JavaScript 向函數(shù)式編程更近了一步。

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

    在 React 應(yīng)用程序中使用 JavaScript 箭頭函數(shù)通常是為了讓代碼保持簡潔和可讀。我很喜歡箭頭函數(shù)，總是嘗試將我的函數(shù)從 JavaScript ES5 重構(gòu)成 ES6。在某些時候，當(dāng) JavaScript ES5 函數(shù)和 JavaScript ES6 函數(shù)之間的差異很明顯時，我會使用 JavaScript ES6 的箭頭函數(shù)。不過，對 React 新手來說，太多不同的語法可能會讓人不知所措。因此，在 React 中使用它們之前，我會嘗試解釋 JavaScript 函數(shù)的不同特點。在以下部分，你將了解到如何在 React 中使用 JavaScript 箭頭函數(shù)。

    在 React 中將函數(shù)視為組件

    React 使用了不同的編程范式，這要歸功于 JavaScript 是一門“多面手”編程語言。在面向?qū)ο缶幊谭矫?，React 的類組件可以很好地利用 JavaScript 類（React 組件 API 的繼承、類方法和類屬性，如 this.state）。另一方面，React（及其生態(tài)系統(tǒng)）也使用了很多函數(shù)式編程的概念。例如，React 的函數(shù)無狀態(tài)組件是另一種定義 React 組件的方式。那么，如果可以像函數(shù)那樣使用組件，將會怎樣？

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

    這是一個接收輸入（例如 props）并返回 HTML 元素（視圖）的函數(shù)。它不需要管理任何狀態(tài)（無狀態(tài)），也不需要了解任何方法（類方法、生命周期方法）。這個函數(shù)只需要使用 React 組件的 render() 方法來進(jìn)行渲染。

     
 
 
      
  
  
  
    1. function Greeting(props) { 
      2. 
  
  
  
    2.   return 
      {props.greeting}
      ; 
      3. 
  
  
  
    3. }
      4.

    功能無狀態(tài)組件是在 React 中定義組件的***方法。它們的樣板代碼較少，復(fù)雜性較低，并且比 React 類組件更易于維護(hù)。不過，這兩者都有自己存在的理由。

    之前提到了 JavaScript 箭頭函數(shù)以及它們可以提升代碼的可讀性，現(xiàn)在讓我們將這些函數(shù)應(yīng)用無狀態(tài)組件中。之前的 Greeting 組件在 JavaScript ES5 和 ES6 中的寫法有點不一樣：

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

    JavaScript 箭頭函數(shù)是讓 React 無狀態(tài)組件保持簡潔的一個不錯的方法。

    React 類組件語法

    React 定義組件的方式一直在演化。在早期階段，React.createClass() 方法是創(chuàng)建 React 類組件的默認(rèn)方式。現(xiàn)在不再使用這個方法，因為隨著 JavaScript ES6 的興起，之前的 React 類組件語法成為默認(rèn)語法。

    不過，JavaScript 也在不斷發(fā)展，因此 JavaScript 愛好者一直在尋找新的方式。這就是為什么你會發(fā)現(xiàn) React 類組件使用了不同的語法。使用狀態(tài)和類方法來定義 React 類組件的一種方法如下：

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

    • 不過，在實現(xiàn)大量的 React 類組件時，構(gòu)造函數(shù)中的類方法綁定和構(gòu)造函數(shù)本身就變成了繁瑣的實現(xiàn)細(xì)節(jié)。所運的是，有一個簡短的語法可用來擺脫這兩個煩惱：

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

    • 通過使用 JavaScript 箭頭函數(shù)，可以自動綁定類方法，不需要在構(gòu)造函數(shù)中綁定它們。通過將狀態(tài)直接定義為類屬性，在不使用 props 時就可以省略構(gòu)造函數(shù)。（注意：請注意，JavaScript 還不支持類屬性。）因此，你可以說這種定義 React 類組件的方式比其他版本更簡潔。

    React 中的模板字面量

    模板字面量是 JavaScript ES6 附帶的另一種 JavaScript 語言特性。之所以提到這個特性，是因為當(dāng) JavaScript 和 React 新手看到它們時，可能會感到困惑。以下面的連接字符串的語法為例：

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

    模板字面量可以用于達(dá)到相同的目的，被稱為字符串插值：

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

    你只需使用反引號和 ${}來插入 JavaScript 原語。字符串字面量不僅可用于字符串插值，還可用于多行字符串：

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

    這樣就可以格式化多行文本塊。

    React 中 Map、Reduce 和 Filter

    在向 React 新手教授 JSX 語法時，我通常會先在 render() 方法中定義一個變量，然后將其用在返回代碼塊中。

     
 
 
      
  
  
  
    1. import React, { Component } from 'react'; 
      2. 
  
  
  
    2. class App extends Component { 
      3. 
  
  
  
    3.   render() { 
      4. 
  
  
  
    4.     var greeting = 'Welcome to React'; 
      5. 
  
  
  
    5.     return ( 
      6. 
  
  
  
    6.       
       
      7. 
  
  
  
    7.         
      {greeting}
       
      8. 
  
  
  
    8.       
     
  •     ); 
  •   } 
  • } 
  • export default App;

    • 你只需使用花括號來操作 HTML 中的 JavaScript。不管是渲染字符串還是渲染一個復(fù)雜的對象，并沒有太大不同。

     
 
 
      
  
  
  
    1. import React, { Component } from 'react'; 
      2. 
  
  
  
    2. class App extends Component { 
      3. 
  
  
  
    3.   render() { 
      4. 
  
  
  
    4.     var user = { name: 'Robin' }; 
      5. 
  
  
  
    5.     return ( 
      6. 
  
  
  
    6.       
       
      7. 
  
  
  
    7.         
      {user.name}
       
      8. 
  
  
  
    8.       
     
  •     ); 
  •   } 
  • } 
  • export default App;

    •  接下來的問題是：如何渲染項目列表？React 沒有提供特定的 API（例如 HTML 標(biāo)記的自定義屬性）用于渲染項目列表。我們可以使用純 JavaScript 代碼來迭代項目列表，并返回每個項目的 HTML。

     
 
 
      
  
  
  
    1. import React, { Component } from 'react'; 
      2. 
  
  
  
    2. class App extends Component { 
      3. 
  
  
  
    3.   render() { 
      4. 
  
  
  
    4.     var users = [ 
      5. 
  
  
  
    5.       { name: 'Robin' }, 
      6. 
  
  
  
    6.       { name: 'Markus' }, 
      7. 
  
  
  
    7.     ]; 
      8. 
  
  
  
    8.     return ( 
      9. 
  
  
  
    9.       
         
  
  
  
      •         {users.map(function (user) { 
        • 
  
  
  
      •           return 
      • {user.name}
        • ; 
  
  
  
      •         })} 
        • 
  
  
  
      •       
       
      10. 
  
  
  
    10.     ); 
      11. 
  
  
  
    11.   } 
      12. 
  
  
  
    12. } 
      13. 
  
  
  
    13. export default App;
      14.

     通過使用 JavaScript 箭頭函數(shù)，你可以擺脫箭頭函數(shù)體和 return 語句，讓渲染輸出更加簡潔。

     
 
 
      
  
  
  
    1. import React, { Component } from 'react'; 
      2. 
  
  
  
    2. class App extends Component { 
      3. 
  
  
  
    3.   render() { 
      4. 
  
  
  
    4.     var users = [ 
      5. 
  
  
  
    5.       { name: 'Robin' }, 
      6. 
  
  
  
    6.       { name: 'Markus' }, 
      7. 
  
  
  
    7.     ]; 
      8. 
  
  
  
    8.     return ( 
      9. 
  
  
  
    9.       
         
  
  
  
      •         {users.map(user => 
      • {user.name}
        • )} 
  
  
  
      •       
       
      10. 
  
  
  
    10.     ); 
      11. 
  
  
  
    11.   } 
      12. 
  
  
  
    12. }
      13. 
  
  
  
    13. 
  
  
  
    14. export default App;
      15.

    很快，每個 React 開發(fā)人員都習(xí)慣了 JavaScript 內(nèi)置的 map() 方法。對數(shù)組進(jìn)行 map 并返回每個項的渲染輸出，這樣做非常有用。在某系情況下，結(jié)合使用 filter() 或 reduce() 會更有用，而不只是為每個被 map 的項渲染輸出。

     
 
 
      
  
  
  
    1. import React, { Component } from 'react'; 
      2. 
  
  
  
    2. class App extends Component { 
      3. 
  
  
  
    3.   render() { 
      4. 
  
  
  
    4.     var users = [ 
      5. 
  
  
  
    5.       { name: 'Robin', isDeveloper: true }, 
      6. 
  
  
  
    6.       { name: 'Markus', isDeveloper: false }, 
      7. 
  
  
  
    7.     ]; 
      8. 
  
  
  
    8.     return ( 
      9. 
  
  
  
    9.       
         
  
  
  
      •         {users 
        • 
  
  
  
      •           .filter(user => user.isDeveloper) 
        • 
  
  
  
      •           .map(user => 
      • {user.name}
        • ) 
  
  
  
      •         } 
        • 
  
  
  
      •       
       
      10. 
  
  
  
    10.     ); 
      11. 
  
  
  
    11.   } 
      12. 
  
  
  
    12. } 
      13. 
  
  
  
    13. 
  
  
  
    14. export default App;
      15.

    通常，React 開發(fā)人員習(xí)慣于使用 JavaScript 的這些內(nèi)置函數(shù)，而不必使用 React 特定的 API。它只是 HTML 中的 JavaScript。

    React 中的 var、let 和 const

    對于 React 的新手來說，使用 var、let 和 const 來聲明變量可能也會給他們造成混淆，雖然它們不是 React 相關(guān)的。我會嘗試在教學(xué)中盡早介紹 let 和 const，并從在 React 組件中交替使用 const 和 var 開始：

     
 
 
      
  
  
  
    1. import React, { Component } from 'react'; 
      2. 
  
  
  
    2. class App extends Component {
      3. 
  
  
  
    3.    render() { 
      4. 
  
  
  
    4.     const users = [ 
      5. 
  
  
  
    5.       { name: 'Robin' }, 
      6. 
  
  
  
    6.       { name: 'Markus' }, 
      7. 
  
  
  
    7.     ]; 
      8. 
  
  
  
    8.     return ( 
      9. 
  
  
  
    9.       
         
  
  
  
      •         {users.map(user => 
      • {user.name}
        • )} 
  
  
  
      •       
       
      10. 
  
  
  
    10.     );
      11. 
  
  
  
    11.    } 
      12. 
  
  
  
    12. } 
      13. 
  
  
  
    13. export default App;
      14.

    然后我給出了一些使用這些變量聲明的經(jīng)驗法則：

    （1）不要使用 var，因為 let 和 const 更具體

    （2）默認(rèn)使用 const，因為它不能被重新分配或重新聲明

    （3）如果要重新賦值變量則使用 let

    let 通常用于 for 循環(huán)中，const 通常用于保持 JavaScript 變量不變。盡管在使用 const 時可以修改對象和數(shù)組的內(nèi)部屬性，但變量聲明表達(dá)了保持變量不變的意圖。

    React 中的三元運算符

    如果要通過 if-else 語句進(jìn)行條件渲染該怎么辦？我們不能直接在 JSX 中使用 if-else 語句，但可以從渲染函數(shù)中提前返回。如果不需要顯示內(nèi)容，返回 null 在 React 中是合法的。

     
 
 
      
  
  
  
    1. import React, { Component } from 'react'; 
      2. 
  
  
  
    2. class App extends Component {
      3. 
  
  
  
    3.    render() { 
      4. 
  
  
  
    4.     const users = [ 
      5. 
  
  
  
    5.       { name: 'Robin' },
      6. 
  
  
  
    6.       { name: 'Markus' }, 
      7. 
  
  
  
    7.     ]; 
      8. 
  
  
  
    8.     const showUsers = false; 
      9. 
  
  
  
    9.     if (!showUsers) { 
      10. 
  
  
  
    10.       return null; 
      11. 
  
  
  
    11.     }
      12. 
  
  
  
    12. 
  
  
  
    13.     return ( 
      14. 
  
  
  
    14.       
         
  
  
  
      •         {users.map(user => 
      • {user.name}
        • )} 
  
  
  
      •       
       
      15. 
  
  
  
    15.     );
      16. 
  
  
  
    16.    } 
      17. 
  
  
  
    17. }
      18. 
  
  
  
    18.  
      19. 
  
  
  
    19. 
  
  
  
    20. export default App;
      21.

    不過，如果要在返回的 JSX 中使用 if-else 語句，可以使用 JavaScript 的三元運算符：

     
 
 
      
  
  
  
    1. import React, { Component } from 'react'; 
      2. 
  
  
  
    2. class App extends Component { 
      3. 
  
  
  
    3.   render() { 
      4. 
  
  
  
    4.     const users = [ 
      5. 
  
  
  
    5.       { name: 'Robin' }, 
      6. 
  
  
  
    6.       { name: 'Markus' }, 
      7. 
  
  
  
    7.     ];
      8. 
  
  
  
    8. 
  
  
  
    9.     const showUsers = false; 
      10. 
  
  
  
    10.     return ( 
      11. 
  
  
  
    11.       
       
      12. 
  
  
  
    12.         { 
      13. 
  
  
  
    13.           showUsers ? ( 
      14. 
  
  
  
    14.             
         
  
  
  
      •               {users.map(user => 
      • {user.name}
        • )} 
  
  
  
      •             
       
      15. 
  
  
  
    15.           ) : ( 
      16. 
  
  
  
    16.             null 
      17. 
  
  
  
    17.           ) 
      18. 
  
  
  
    18.         }
      19. 
  
  
  
    19.        
     
  •     ); 
  •   } 
  • } 
  • export default App;

    • 如果你只返回條件渲染的一個方面，可以使用 && 運算符：

     
 
 
      
  
  
  
    1. import React, { Component } from 'react';
      2. 
  
  
  
    2. 
  
  
  
    3. class App extends Component {
      4. 
  
  
  
    4. 
  
  
  
    5.   render() {
      6. 
  
  
  
    6. 
  
  
  
    7.     const users = [
      8. 
  
  
  
    8. 
  
  
  
    9.       { name: 'Robin' },
      10. 
  
  
  
    10. 
  
  
  
    11.       { name: 'Markus' },
      12. 
  
  
  
    12. 
  
  
  
    13.     ];
      14. 
  
  
  
    14. 
  
  
  
    15.     const showUsers = false; 
      16. 
  
  
  
    16. 
  
  
  
    17.     return (
      18. 
  
  
  
    18. 
  
  
  
    19.       
      20. 
  
  
  
    20. 
  
  
  
    21.         {
      22. 
  
  
  
    22. 
  
  
  
    23.           showUsers && ( 
      24. 
  
  
  
    24.             
         
  
  
  
      •               {users.map(user => 
      • {user.name}
        • )} 
  
  
  
      •             
       
      25. 
  
  
  
    25.           )
      26. 
  
  
  
    26.          } 
      27. 
  
  
  
    27.       
     
  •     ); 
  •   } 
  • } 
  • export default App;

    • 詳細(xì)的原理我就不說了，但如果你感興趣，可以在這篇文章（https://www.robinwieruch.de/conditional-rendering-react/）里了解到更詳細(xì)的信息以及與條件渲染相關(guān)的其他技術(shù)。React 中的條件渲染告訴我們，大多數(shù) React 都是與 JavaScript 有關(guān)，而不是 React 特定的內(nèi)容。

    React 中的導(dǎo)入和導(dǎo)出語句

    在 JavaScript 中，我們可以通過 import 和 export 語句來導(dǎo)入和導(dǎo)出在 JavaScript ES6 文件中定義的功能。

    在開始你的***個 React 應(yīng)用程序之前，這些 import 和 export 語句是另一個需要了解的話題。create-react-app 項目已經(jīng)在使用 import 語句：

     
 
 
      
  
  
  
    1. import React, { Component } from 'react'; 
      2. 
  
  
  
    2. import logo from './logo.svg'; 
      3. 
  
  
  
    3. import './App.css'; 
      4. 
  
  
  
    4. class App extends Component { 
      5. 
  
  
  
    5.   render() { 
      6. 
  
  
  
    6.     return ( 
      7. 
  
  
  
    7.        
      8. 
  
  
  
    8.          
      9. 
  
  
  
    9.            
      10. 
  
  
  
    10.           Welcome to React 
      11. 
  
  
  
    11.          
      12. 
  
  
  
    12.          
      13. 
  
  
  
    13.           To get started, edit src/App.js and save to reload. 
      14. 
  
  
  
    14.         
       
      15. 
  
  
  
    15.       
     
  •     ); 
  •   } 
  • } 
  • export default App;

    • 這對初始項目來說非常棒，因為它為你提供了一個全面的體驗，可以導(dǎo)入和導(dǎo)出其他文件。不過，在剛開始接觸 React 時，我會試著避免這些導(dǎo)入。相反，我會專注于 JSX 和 React 組件。在需要將 React 組件或 JavaScript 函數(shù)分離到單獨的文件中時，才需要引入導(dǎo)入和導(dǎo)出語句。

    那么這樣使用這些導(dǎo)入和導(dǎo)出語句呢？假設(shè)你想要導(dǎo)出一個文件的如下變量：

     
 
 
      
  
  
  
    1. const firstname = 'Robin'; 
      2. 
  
  
  
    2. const lastname = 'Wieruch'; 
      3. 
  
  
  
    3. export { firstname, lastname };
      4.

    然后，你可以通過***個文件的相對路徑將它們導(dǎo)入到另一個文件中：

     
 
 
      
  
  
  
    1. import { firstname, lastname } from './file1.js'; 
      2. 
  
  
  
    2. console.log(firstname); 
      3. 
  
  
  
    3. // output: Robin
      4.

    因此，它不一定只是與導(dǎo)入或?qū)С鼋M件或函數(shù)有關(guān)，它可以是共享可分配給變量的所有東西（我們只談 JS）。你還可以將另一個文件導(dǎo)出的所有變量作為一個對象導(dǎo)入：

     
 
 
      
  
  
  
    1. import * as person from './file1.js'; 
      2. 
  
  
  
    2. console.log(person.firstname); 
      3. 
  
  
  
    3. // output: Robin
      4.

    導(dǎo)入可以有別名。當(dāng)從多個文件導(dǎo)入具有相同導(dǎo)出名稱的功能時，就需要用到別名。

     
 
 
      
  
  
  
    1. import { firstname as username } from './file1.js'; 
      2. 
  
  
  
    2. console.log(username); 
      3. 
  
  
  
    3. // output: Robin
      4.

    之前所有的例子都是命名的導(dǎo)入和導(dǎo)出。除此之外，還有默認(rèn)的導(dǎo)入和導(dǎo)出。它可以用于以下一些場景：

     
 
 
      
  
  
  
    1. const robin = { 
      2. 
  
  
  
    2.   firstname: 'Robin', 
      3. 
  
  
  
    3.   lastname: 'Wieruch', 
      4. 
  
  
  
    4. }; 
      5. 
  
  
  
    5. export default robin;
      6.

    在使用默認(rèn)導(dǎo)入時可以省略大括號：

     
 
 
      
  
  
  
    1. import developer from './file1.js'; 
      2. 
  
  
  
    2. console.log(developer); 
      3. 
  
  
  
    3. // output: { firstname: 'Robin', lastname: 'Wieruch' }
      4.

    此外，導(dǎo)入名稱可以與導(dǎo)出的默認(rèn)名稱不同。你還可以將它與命名的 export 和 import 語句一起使用：

     
 
 
      
  
  
  
    1. const firstname = 'Robin'; 
      2. 
  
  
  
    2. const lastname = 'Wieruch'; 
      3. 
  
  
  
    3. const person = { 
      4. 
  
  
  
    4.   firstname, 
      5. 
  
  
  
    5.   lastname, 
      6. 
  
  
  
    6. }; 
      7. 
  
  
  
    7. export { 
      8. 
  
  
  
    8.   firstname, 
      9. 
  
  
  
    9.   lastname, 
      10. 
  
  
  
    10. }; 
      11. 
  
  
  
    11. export default person;
      12.

    在另一個文件中導(dǎo)入：

     
 
 
      
  
  
  
    1. import developer, { firstname, lastname } from './file1.js'; 
      2. 
  
  
  
    2. console.log(developer); 
      3. 
  
  
  
    3. // output: { firstname: 'Robin', lastname: 'Wieruch' } 
      4. 
  
  
  
    4. console.log(firstname, lastname); 
      5. 
  
  
  
    5. // output: Robin Wieruch
      6.

    你還可以節(jié)省一些行，直接導(dǎo)出命名的變量：

     
 
 
      
  
  
  
    1. export const firstname = 'Robin'; 
      2. 
  
  
  
    2. export const lastname = 'Wieruch';
      3.

    這些是 ES6 模塊的主要功能。它們可以幫助你更好地組織代碼，并設(shè)計出可重用的模塊 API。

    React 中的庫

    React 只是應(yīng)用程序的視圖層。React 提供了一些內(nèi)部狀態(tài)管理，但除此之外，它只是一個為瀏覽器渲染 HTML 的組件庫。API（例如瀏覽器 API、DOM API）、JavaScript 或外部庫可以為 React 添加額外的東西。為 React 應(yīng)用程序選擇合適的庫并不是件容易的事，但一旦你對不同的庫有了很好的了解，就可以選擇最適合你的技術(shù)棧的庫。

    例如，我們可以使用 React 原生的獲取數(shù)據(jù)的 API 來獲取數(shù)據(jù)：

     
 
 
      
  
  
  
    1. import React, { Component } from 'react'; 
      2. 
  
  
  
    2. class App extends Component { 
      3. 
  
  
  
    3.   state = { 
      4. 
  
  
  
    4.     data: null, 
      5. 
  
  
  
    5.   }; 
      6. 
  
  
  
    6.   componentDidMount() { 
      7. 
  
  
  
    7.     fetch('https://api.mydomain.com') 
      8. 
  
  
  
    8.       .then(response => response.json())
      9. 
  
  
  
    9.       .then(data => this.setState({ data })); 
      10. 
  
  
  
    10.   }  
      11. 
  
  
  
    11. 
  
  
  
    12.   render() { 
      13. 
  
  
  
    13.     ... 
      14. 
  
  
  
    14.   } 
      15. 
  
  
  
    15. } 
      16. 
  
  
  
    16. export default App;
      17.

    但你也可以使用另一個庫來獲取數(shù)據(jù)，Axios 就是這樣的一個流行庫：

     
 
 
      
  
  
  
    1. import React, { Component } from 'react'; 
      2. 
  
  
  
    2. import axios from 'axios'; 
      3. 
  
  
  
    3. class App extends Component { 
      4. 
  
  
  
    4.   state = { 
      5. 
  
  
  
    5.     data: null, 
      6. 
  
  
  
    6.   }; 
      7. 
  
  
  
    7.   componentDidMount() { 
      8. 
  
  
  
    8.     axios.get('https://api.mydomain.com') 
      9. 
  
  
  
    9.       .then(data => this.setState({ data })); 
      10. 
  
  
  
    10.   }
      11. 
  
  
  
    11. 
  
  
  
    12.   render() { 
      13. 
  
  
  
    13.     ... 
      14. 
  
  
  
    14.   } 
      15. 
  
  
  
    15. } 
      16. 
  
  
  
    16. export default App;
      17.

    因此，一旦你知道了需要解決什么問題，React 的生態(tài)系統(tǒng)就可以為你提供大量的解決方案。這可能與 React 本身無關(guān)，而是有關(guān)了解如何選擇可用于彌補(bǔ) React 應(yīng)用程序的各種 JavaScript 庫。

    React 中的高階函數(shù)

    高階函數(shù)是函數(shù)式編程中的一個非常棒的概念。在 React 中，了解這些函數(shù)是非常有意義的，因為在某些時候你需要處理高階組件，如果已經(jīng)了解了高階函數(shù)，那么就可以更好地了解這些高階組件。

    我們假設(shè)可以根據(jù)一個輸入字段的值對用戶列表進(jìn)行過濾。

     
 
 
      
  
  
  
    1. import React, { Component } from 'react'; 
      2. 
  
  
  
    2. class App extends Component { 
      3. 
  
  
  
    3.   state = { 
      4. 
  
  
  
    4.     query: '', 
      5. 
  
  
  
    5.   }; 
      6. 
  
  
  
    6.   onChange = event => { 
      7. 
  
  
  
    7.     this.setState({ query: event.target.value }); 
      8. 
  
  
  
    8.   } 
      9. 
  
  
  
    9.   render() { 
      10. 
  
  
  
    10.     const users = [ 
      11. 
  
  
  
    11.       { name: 'Robin' }, 
      12. 
  
  
  
    12.       { name: 'Markus' }, 
      13. 
  
  
  
    13.     ]; 
      14. 
  
  
  
    14.     return (  <                                                
      
                                                新聞名稱：在開始React之前，你需要學(xué)好這些JavaScript                                                
      
                                                分享地址：http://m.5511xx.com/article/dpopjsc.html

    其他資訊