Alexis Gilbert

Alexis Gilbert

1665724224

Latest Hourly rate of Fullstack developer in 2023!

#fullstack #programmiing 

Full stack developer has been a backbone of an application. If you have picked the right front-end and back-end technology it can give your app a significant boost in no time. In order to hire well-versed Full stack developers, you need to consider multiple attributes that can make or break the game for you.

When you are a beginner in the industry or have a start-up there it becomes vital to consider the cost factors that highly affect the web development procedure considering multiple factors like Full stack web and mobile development services, MEAN stack developer, Full stack support, and maintenance.

In order to hire the right Full stack developer first, you need to identify the core requirement of the project and the significant budget you have decided to spend after one project.


Cost is one of the prime factors that matter in a developing world. So, in order to get a head start with your hunt for finding the right full stack developer for your project.

Roadmap to become a full stack developer in 2022
The hourly cost of a Full stack developer highly depends on the expertise of a developer or the location where he is located.

Let's get more details in brief.

Hourly rate of Full stack developer

On average, the Hourly rate of a Full stack developer varies from around $25 to $50 depending upon the size of your project and the core expertise of the developer that they bring to the table.

Apart from that, it highly depends upon the full stack technology you use too. For instance, if it falls under one of the popular combinations stated below the hourly rate can differ in accordance with that.

  1. Angular + .NET core
  2. React + NodeJS
  3. React + Django
  4. Laravel + VueJS
  5. Python + Angular


Monthly Rate of Full stack developer


The mechanism for the monthly rate of full stack developers is quite different from the hourly rate as they generally are targeted towards projects that take years to get completed. So, in other words, the monthly rate differs based on the type of requirement the project has and the expertise the project seeks from the full stack developers.

Generally, the monthly rate of Full stack developer starts from $3000 depending upon which full stack development company you hire for your project. This price may reach upto $10000 to $15000 depending upon the nature of the project and the duration of the web development process.


If you are seeking to hire one of the best Full stack web development teams you can get started by getting connected with one of the best in the industry. Hire Full Stack developer from Bacancy and get your idea transformed into digital reality with top-notch resources.


 

Tutorial: How to implement infinite loading with URQL GraphQL

So you're tasked with implementing an infinite loading pattern on mobile using a graphql schema. Let me share my knowledge on how to implement infinite loading on URQL on a Next.js Project. In this tutorial, I'll be showing you on how to implement infinite loading on URQL with rick and morty api as our backend endpoint

Infinite loading a is very common pattern in mobile layout since it's optimized for mobile UX as opposed to pagination which is more for desktop.  There are many ways to implement infinite loading in URQL however today I'm going to show to you probably the most simple pattern to implement infinite loading pattern using a custom hook. 

Check it out here 👉: https://reacthustle.com/blog/tutorial-how-to-implement-infinite-loading-with-urql-graphql

#nextjs  #graphql #frontend #fullstack #urql #apollo 

5 Next.js Routing Best Practices

Today I'm going to share with you next.js routing 5 best practices. These will be useful for a production grade application and try optimize the performance score on lighthouse. This article assumes that you have a basic understanding of next.js routing. This article touches on a few points that will sure come in handy! 

useRouter hook is a pretty straight forward react hook in next.js but sometimes it can cause performance issues and unwanted behavior when we fail to notice minor details when implementing a component.  

Checkout the link below: 👇

https://reacthustle.com/blog/5-nextjs-routing-best-practices

 

#nextjs  #react  #FrontEnd  #frontend #fullstack 

10 Favorite Golang Libraries for Full Stack Web Frameworks

In today's post we will learn about 10 Favorite Golang Libraries for Full Stack Web Frameworks.

What is Full Stack Web Frameworks?

A full-stack development framework is designed to be utilized repetitively by developers to program applications without manually creating the regularly used generic codes from scratch. To put it simply, they are bodies of pre-written code used by developers to create apps using the Java programming language.

Table of contents:

  • Aero - High-performance web framework for Go, reaches top scores in Lighthouse.
  • Air - An ideally refined web framework for Go.
  • Anoweb - The lightweight and powerful web framework using the new way for Go.Another go the way.
  • Appy - An opinionated productive web framework that helps scaling business easier.
  • Banjo - Very simple and fast web framework for Go.
  • Beego - beego is an open-source, high-performance web framework for the Go programming language.
  • Echo - High performance, minimalist Go web framework.
  • Fiber - An Express.js inspired web framework build on Fasthttp.
  • Fireball - More "natural" feeling web framework.
  • Flamingo - Framework for pluggable web projects. Including a concept for modules and offering features for DI, Configareas, i18n, template engines, graphql, observability, security, events, routing & reverse routing etc.

1 - Aero:

High-performance web framework for Go, reaches top scores in Lighthouse.

Installation

go get -u github.com/aerogo/aero/...

Benchmarks

Web server performance

Features

  • HTTP/2
  • Radix tree routing
  • Low latency
  • Bandwidth savings via automated ETags
  • Session data with custom stores
  • Server-sent events
  • Context interface for custom contexts

View on Github

2 - Air:

An ideally refined web framework for Go.

High-performance? Fastest? Almost all web frameworks are using these words to tell people that they are the best. Maybe they are, maybe not. Air does not intend to follow the crowd. Our goal is always to strive to make it easy for people to use Air to build their web applications. So, we can only guarantee you one thing: Air can serve properly.

Installation

Open your terminal and execute

$ go get github.com/aofei/air

done.

The only requirement is the Go, at least v1.13.

Hello, 世界

Create a file named hello.go

package main

import "github.com/aofei/air"

func main() {
	air.Default.GET("/", func(req *air.Request, res *air.Response) error {
		return res.WriteString("Hello, 世界")
	})
	air.Default.Serve()
}

and run it

$ go run hello.go

then visit http://localhost:8080.

Documentation

Does all web frameworks need to have a complicated (or a lovely but lengthy) website to guide people how to use them? Well, Air has only one Doc with useful comments. In fact, Air is so succinct that you don't need to understand how to use it through a large document.

Gases

As we all know that the air of Earth is a mixture of gases. So the same is that Air adopts the gas as its composition. Everyone can create new gas and use it within Air simply.

A gas is a function chained in the HTTP request-response cycle with access to the air.Request and air.Response which it uses to perform a specific action, for example, logging every request or recovering from panics.

return func(next air.Handler) air.Handler {
	return func(req *air.Request, res *air.Response) error {
		// Do something here...
		return next(req, res) // Execute the next handler
	}
}

If you already have some good HTTP middleware, you can simply wrap them into gases by calling the air.WrapHTTPMiddleware.

If you are looking for some useful gases, simply visit here.

View on Github

3 - Anoweb:

The lightweight and powerful web framework using the new way for Go.Another go the way.

                                    _
                                   | |
 _____  ____    ___   _ _ _  _____ | |__
(____ ||  _ \  / _ \ | | | || ___ ||  _ \ 
/ ___ || | | || |_| || | | || ____|| |_) )
\_____||_| |_| \___/  \___/ |_____)|____/ 

::anoweb:: 

The lightweight and powerful web framework using the new way for Go. Another go the way.

{{ Version @VER }}

{{ Powered by go-the-way }}

{{ https://github.com/go-the-way/anoweb }}

Install

require github.com/go-the-way/anoweb latest

Quickstart

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"time"
	
	"github.com/go-the-way/anoweb"
	"github.com/go-the-way/anoweb/context"
)

func main() {
	go func() {
		time.AfterFunc(time.Second, func() {
			response, _ := http.Get("http://localhost:9494")
			resp, _ := ioutil.ReadAll(response.Body)
			fmt.Println(string(resp))
		})
	}()
	anoweb.Default.Get("/", func(ctx *context.Context) {
		ctx.Text("Hello world")
	}).Run()
}

View on Github

4 - Appy:

An opinionated productive web framework that helps scaling business easier, i.e. focus on monolith first, only move to microservices with GRPC later on when your team is ready.

Click to see an application called "appist" made with "appy" in action

Debug Mode     Release Mode

Additional Notes

  • appy is made as a package for your application to import without the need to install any additional binary
  • appy glues the great packages to provide best productivity in developing Go web application
  • appy comes with 2 build types:
    • debug - when the code is NOT running within the binary
    • release - when the code is running within the binary
  • appy follows 12factor via APPY_ENV environment variable:
    • by default, it is development
    • when APPY_ENV=staging is set, the config file is configs/.env.staging
    • utilise configs/.env.<APPY_ENV> to support multiple environments deployment

Quick Start

Step 1: Create the project folder with go module and git initialised.

$ mkdir <PROJECT_NAME> && cd $_ && go mod init $_ && git init

Note: The <PROJECT_NAME> must be an alphanumeric string.

Step 2: Create main.go with the snippet below.

package main

import (
  "github.com/appist/appy/cmd"
)

func main() {
  err := cmd.Scaffold()

  if err != nil {
    panic(err)
  }
}

Step 3: Initialize the project layout.

$ go run .

Step 4: Setup the databases using Docker Compose.

$ go run . setup

Step 5: Start developing your application locally.

$ go run . start

View on Github

5 - Banjo:

Very simple and fast web framework for Go.

Install

$ go get github.com/nsheremet/banjo

Example Usage

Simple Web App - main.go

package main

import "banjo"

func main() {
  app := banjo.Create(banjo.DefaultConfig())
  
  app.Get("/", func(ctx *banjo.Context) {
    ctx.JSON(banjo.M{"foo":"bar"})
  })

  app.Run()
}

Example responses:

// ... Redirect To
  app.Get("/admin", func(ctx *banjo.Context) {
    ctx.RedirectTo("/")
  })
// ... HTML
  app.Get("/foo", func(ctx *banjo.Context) {
    ctx.HTML("<h1>Hello from BONjO!</h1>")
  })
// ... Return Params as JSON
  app.Post("/bar", func(ctx *banjo.Context) {
    ctx.JSON(banjo.M{
      "params": ctx.Request.Params
    })
    ctx.Response.Status = 201
  })

View on Github

6 - Beego:

Beego is an open-source, high-performance web framework for the Go programming language.

Beego is composed of four parts:

  1. Base modules: including log module, config module, governor module;
  2. Task: is used for running timed tasks or periodic tasks;
  3. Client: including ORM module, httplib module, cache module;
  4. Server: including web module. We will support gRPC in the future;

Please use RELEASE version, or master branch which contains the latest bug fix

Quick Start

Official website 中文新版文档网站

Example

If you could not open official website, go to beedoc

Web Application

Http Request

Create hello directory, cd hello directory

mkdir hello
cd hello

Init module

go mod init

Download and install

go get github.com/beego/beego/v2@latest

Create file hello.go

package main import "github.com/beego/beego/v2/server/web" func main() { web.Run() }

Build and run

go build hello.go
./hello

Go to http://localhost:8080

Congratulations! You've just built your first beego app.

View on Github

7 - Echo:

High performance, minimalist Go web framework.

Feature Overview

  • Optimized HTTP router which smartly prioritize routes
  • Build robust and scalable RESTful APIs
  • Group APIs
  • Extensible middleware framework
  • Define middleware at root, group or route level
  • Data binding for JSON, XML and form payload
  • Handy functions to send variety of HTTP responses
  • Centralized HTTP error handling
  • Template rendering with any template engine
  • Define your format for the logger
  • Highly customizable
  • Automatic TLS via Let’s Encrypt
  • HTTP/2 support

Guide

Installation

// go get github.com/labstack/echo/{version}
go get github.com/labstack/echo/v4

Example

package main

import (
  "github.com/labstack/echo/v4"
  "github.com/labstack/echo/v4/middleware"
  "net/http"
)

func main() {
  // Echo instance
  e := echo.New()

  // Middleware
  e.Use(middleware.Logger())
  e.Use(middleware.Recover())

  // Routes
  e.GET("/", hello)

  // Start server
  e.Logger.Fatal(e.Start(":1323"))
}

// Handler
func hello(c echo.Context) error {
  return c.String(http.StatusOK, "Hello, World!")
}

View on Github

8 - Fiber:

An Express.js inspired web framework build on Fasthttp.

Fiber is an Express inspired web framework built on top of Fasthttp, the fastest HTTP engine for Go. Designed to ease things up for fast development with zero memory allocation and performance in mind.

⚡️ Quickstart

package main

import "github.com/gofiber/fiber/v2"

func main() {
    app := fiber.New()

    app.Get("/", func(c *fiber.Ctx) error {
        return c.SendString("Hello, World 👋!")
    })

    app.Listen(":3000")
}

⚙️ Installation

Make sure you have Go installed (download). Version 1.14 or higher is required.

Initialize your project by creating a folder and then running go mod init github.com/your/repo (learn more) inside the folder. Then install Fiber with the go get command:

go get -u github.com/gofiber/fiber/v2

👀 Examples

Listed below are some of the common examples. If you want to see more code examples , please visit our Recipes repository or visit our hosted API documentation.

📖 Basic Routing

func main() {
    app := fiber.New()

    // GET /api/register
    app.Get("/api/*", func(c *fiber.Ctx) error {
        msg := fmt.Sprintf("✋ %s", c.Params("*"))
        return c.SendString(msg) // => ✋ register
    })

    // GET /flights/LAX-SFO
    app.Get("/flights/:from-:to", func(c *fiber.Ctx) error {
        msg := fmt.Sprintf("💸 From: %s, To: %s", c.Params("from"), c.Params("to"))
        return c.SendString(msg) // => 💸 From: LAX, To: SFO
    })

    // GET /dictionary.txt
    app.Get("/:file.:ext", func(c *fiber.Ctx) error {
        msg := fmt.Sprintf("📃 %s.%s", c.Params("file"), c.Params("ext"))
        return c.SendString(msg) // => 📃 dictionary.txt
    })

    // GET /john/75
    app.Get("/:name/:age/:gender?", func(c *fiber.Ctx) error {
        msg := fmt.Sprintf("👴 %s is %s years old", c.Params("name"), c.Params("age"))
        return c.SendString(msg) // => 👴 john is 75 years old
    })

    // GET /john
    app.Get("/:name", func(c *fiber.Ctx) error {
        msg := fmt.Sprintf("Hello, %s 👋!", c.Params("name"))
        return c.SendString(msg) // => Hello john 👋!
    })

    log.Fatal(app.Listen(":3000"))
}

📖 Route Naming

func main() {
    app := fiber.New()

    // GET /api/register
    app.Get("/api/*", func(c *fiber.Ctx) error {
        msg := fmt.Sprintf("✋ %s", c.Params("*"))
        return c.SendString(msg) // => ✋ register
    }).Name("api")

    data, _ := json.MarshalIndent(app.GetRoute("api"), "", "  ")
    fmt.Print(string(data))
    // Prints:
    // {
    //    "method": "GET",
    //    "name": "api",
    //    "path": "/api/*",
    //    "params": [
    //      "*1"
    //    ]
    // }


    log.Fatal(app.Listen(":3000"))
}

View on Github

9 - Fireball:

More "natural" feeling web framework.

Overview

Fireball is a package for Go web applications. The primary goal of this package is to make routing, response writing, and error handling as easy as possible for developers, so they can focus more on their application logic, and less on repeated patterns.

Installation

To install this package, run:

go get github.com/zpatrick/fireball

Getting Started

The following snipped shows a simple "Hello, World" application using Fireball:

package main

import (
  "github.com/zpatrick/fireball"
  "net/http"
)

func index(c *fireball.Context) (fireball.Response, error) {
  return fireball.NewResponse(200, []byte("Hello, World!"), nil), nil
}

func main() {
  indexRoute := &fireball.Route{
    Path: "/",
    Handlers: fireball.Handlers{
      "GET": index,
    },
  }

  routes := []*fireball.Route{indexRoute}
  app := fireball.NewApp(routes)
  http.ListenAndServe(":8000", app)
}

This will run a new webserver at localhost:8000

View on Github

10 - Flamingo:

Framework for pluggable web projects. Including a concept for modules and offering features for DI, Configareas, i18n, template engines, graphql, observability, security, events, routing & reverse routing etc.

Quick start

See "examples/hello-world"

Initialize an empty project:

mkdir helloworld
cd helloworld
go mod init helloworld

Create your project main file:

cat main.go

package main

import (
	"flamingo.me/dingo"
	"flamingo.me/flamingo/v3"
)

func main() {
	flamingo.App([]dingo.Module{
	})
}

If you then start your project you will see a list of registered commands:

go run main.go

It will print something like:

Flamingo main

Usage:
  main [command]

Examples:
Run with -h or -help to see global debug flags

Available Commands:
  config      Config dump
  handler     Dump the Handlers and its registered methods
  help        Help about any command
  routes      Routes dump
  serve       Default serve command - starts on Port 3322

Flags:
  -h, --help   help for main

Use "main [command] --help" for more information about a command.

To start the server use the following sub command:

go run main.go serve

And open http://localhost:3322

Hello World Example:

To extend this empty flamingo project with a "Hello World" output please create a new module "helloworld" like this:

mkdir helloworld
cat helloworld/module.go

With the following code in module.go:

package helloworld

import (
        "context"
        "net/http"
        "strings"
        
        "flamingo.me/dingo"
        "flamingo.me/flamingo/v3/framework/web"
)

type Module struct{}

func (*Module) Configure(injector *dingo.Injector) {
        web.BindRoutes(injector, new(routes))
}

type routes struct{}

func (*routes) Routes(registry *web.RouterRegistry) {
        registry.Route("/", "home")
        registry.HandleAny("home", indexHandler)
}

func indexHandler(ctx context.Context, req *web.Request) web.Result {
        return &web.Response{
            Status: http.StatusOK,
            Body:   strings.NewReader("Hello World!"),
        }
}

This file now defines a very simple module, that can be used in the Flamingo bootstrap. In this case it registers a new handler that renders a simple "Hello World" message and binds the route "/" to this handler. Now please include this new module in your existing main.go file:

package main

import (
	"flamingo.me/dingo"
	"flamingo.me/flamingo/v3"
	"helloworld/helloworld"
)

func main() {
	flamingo.App([]dingo.Module{
        new(helloworld.Module),
	})
}

If you now run the server again

go run main.go serve

And open http://localhost:3322 you will see your "Hello World!" output.

View on Github

Thank you for following this article.

Related videos:

The Best Tech Stack for Web Developers in 2022

#go #golang #fullstack #webframeworks 

10 Favorite Golang Libraries for Full Stack Web Frameworks
Coding  Life

Coding Life

1662869624

Full Stack Web App : Full Stack Spring Boot and React CRUD 1.5 hours Course

Learn how to create full stack CRUD ( Create, Read, Update, Delete) using Spring boot and React Hooks using Functional Components. We will build Web Services (REST API) using Spring and MySql on Backend and Test using PostMan and handle the same REST API on react in frontend using axios.

Timelapses :

00:00 - Introduction to fullstack 
01:37 - Create Spring Boot project and packages 
05:05 - Create Model Class and connect with MySQL Database 
11:31 - @PostMapping for sending data in database
16:08 - @GetMapping for getting data from database
17:59 - Create React App using npm for frontend 
20:16 - Folder Structure for React app
21:33 - Create Navbar using Bootstrap and React
27:33 - Create Homepage using Bootstrap table
29:43 - Display Information using AXIOS GET
40:27 - Configure Routing using REACT-ROUTER-DOM
46:36 - Create Register User Form using React
52:06 - Store User Information inside state
57:15 - Post data into database AXIOS POST
1:03:04 - Custom Exception Handling
1:09:08 - Edit User using PUTMapping
1:13:57 - Delete the user of specific id
1:16:53 - Edit user using AXIOS PUT
1:22:42 - DELETE User using AXIOS
1:25:13 - View Information of specific User

FULLSTACK CRUD Playlist : https://shorturl.at/gjvDT

Source Code Link : 
----------------------------
Backend : https://github.com/arjungautam1/fullstack-backend 
Frontend : https://github.com/arjungautam1/fullstack-frontend 

➡️ Subscribe : https://www.youtube.com/codewitharjun 


#fullstack  #react #springboot  

Full Stack Web App : Full Stack Spring Boot and React CRUD 1.5 hours Course

React と Node.js を組み合わせてフルスタックの Web アプリを開発する

フルスタックの Web アプリをゼロから構築する場合、可能な限り最も効果的な方法でコードを整理する方法を理解するのは難しい場合があります。Netflix や Prime Videos などのプログレッシブ Web アプリを使用したことがある場合は、それらのシンプルなインターフェイスが複雑な機能に包まれ、強力なバックエンドによって強化されていることを確実に知っています.

Netflix のような Web アプリを開発する場合、データベースが 1 つのことを行い、ルーティング システムが別のことを行い、ビジネス ロジックがアプリケーションのいくつかの側面を一度に処理する必要があります。

一言で言えば、Web アプリの開発とは、ユーザーをアプリに引き付け続ける美しいフロントエンドを作成することです。2 つ目は、アプリをスムーズに実行できる強力なバックエンドを開発することです。

この記事では、React と Node.js を使用してゼロから Web アプリ全体を構築する方法を見ていきます。Js — JavaScript の 2 つの強力なツール。しかし、このブログを読み始める前に、心に残るいくつかの質問を以下に示します。

  • React と Node.js がフロントエンドとバックエンドの開発に人気のある理由は?
    - React と Node.Js: そのベースライン、長所、ユースケースを理解する
  • Node.Js を React で Web アプリ開発に使用できますか?
  • React と Node.Js を使用してフルスタックの Web アプリを作成するのは致命的な組み合わせですか?
  • この Node.JS と React.Js の組み合わせは、このようなビジネスにどのように役立つのでしょうか?
  • まとめ: React.js と Node.js を使用した強力なフルスタック アプリの開発

各ポイントの詳細を掘り下げてみましょう…

React と Node.js がフロントエンドとバックエンドの開発に人気のある理由は?

結論:フロント エンドで一般的に使用される JavaScript ライブラリの React は、魅力的なユーザー インターフェイスを作成できます。対照的に、サーバーで使用されることが多い Node.js は、スケーラブルなアプリを作成できます。React と Node.js を組み合わせることは、フルスタックの Web アプリケーションを構築する開発者にとって非常に有益です。

React と Node.Js: そのベースライン、長所、ユース ケースを理解する

React.JS (フロントエンド JS ライブラリ) の紹介

ReactJS は、再利用可能な UI 要素を作成することで、開発者がデータ駆動型の動的ビューを備えた大規模な Web アプリを構築できるようにする、最も人気のあるフロントエンド JavaScript ライブラリの 1 つです。さらに、複数のデバイス間でスムーズな応答性と機能性を備えています。

画像ソース

Statista によると、React.js は、開発者が複雑なフレームワークやプログラミング言語の知識がなくても、非常に説得力がありスケーラブルな Web アプリを設計できるようにする、最も人気があり、広く使用されている Web フレームワークの 1 つです。React.js は、WhatsApp、Instagram、Netflix、Airbnb などから信頼されています。

ReactJS の主なハイライト

  • React は SEO フレンドリーなフロントエンド JS フレームワークです。
  • 初心者がプロジェクトをすぐに始めるのに役立つ詳細なドキュメントとチュートリアルが付属しています。
  • 仮想 DOM を使用するため、アプリのパフォーマンスが向上します。
  • Web アプリを構築するためのいくつかのコンポーネントをサポートし、動的な Web アプリ開発プロセスを強化します。

React.js の主な機能

  • アクセスと保守がはるかに簡単です
  • 優れたアプリ パフォーマンスを確保する
  • 安定したコードを提供する
  • Web アプリのフロントエンドの開発に最適

React.js のユースケース

  • シングル ページ アプリ (SPA) の構築
  • シームレスなユーザー インターフェイスの作成
  • ウェブ閲覧アプリ
  • 大規模なソーシャル メディア サイトの構築に最適
  • 動的ライブラリ

Web アプリ開発で React.js を包括的に使用するには、大手の React Web 開発会社で働くReact 開発者を雇う価値があります。React を使用したアプリ開発の専門知識と経験を活用して、成功する Web アプリの作成を支援します。

Node.JS (バックエンド JS ライブラリ) の紹介

Node.js は、Google の V8 JavaScript エンジンで作成されます。これは、複数のプラットフォームで実行でき、開発時間を大幅に短縮できるオープンソースのプログラミング言語です。Node.js の助けを借りて JS 言語とモジュールを使用する場合、重複する必要はありません。

統計によると、米国でチェックされた 63,000 以上の Web サイトのうち、37,000 以上の Web サイトが Node.js で実行されています。」

Node.js が Web アプリのバックエンド開発に広く使用されている理由と、アプリ開発に Node アプリ開発者を雇うべき理由を知りたいですか? このデータを信頼する前に、Node.js の正当な理由と利点を説明します。

Node.Js の利点

  • サーバー側とクライアント側の両方のアプリケーションに使用できます。
  • Node は、Chrome の V8 JS エンジンに基づいて、アプリのパフォーマンスを 50% 向上させることができます。
  • ノンブロッキング I/O 操作はランタイム環境をバックアップするため、効率的なコード実行が可能になります。
  • ノードは、他の JS サーバーよりも優れたスケーラビリティを提供します。垂直方向と水平方向の両方のスケーリングをサポートしています。

Node.Js の機能

  • ブロッキングなし、非同期、イベントの発生に依存
  • スケーラブルでありながらスレッド化されていない
  • 開発プロセスを迅速に追跡することをお勧めします。
  • さまざまなデバイスとの互換性
  • バッファリングなしの高速データ ストリーミング
  • 迅速なコード開発
  • JavaScript に基づく

Node.Js のユースケース

  • リアルタイム Web アプリケーション
  • データのストリーミング
  • 複雑な SPA (シングル ページ アプリケーション)
  • サーバー上のプロキシ

Node.js は、強力なバックエンドの構築に役立つ強力な JavaScript ライブラリの 1 つです。優れた Node.js Web 開発会社でNode.js 開発者を雇って、Node.js の主要な機能を利用することができます。

Web アプリ開発に React で Node.JS を使用することは可能ですか?

そのとおりです。Node.js は、スケーラブルで高速なバックエンド RESTful API の作成を容易にします。一方、React はインタラクティブなユーザー インターフェイスを生成するフロントエンド ライブラリです。両方のツールを使用すると、複雑でスケーラブルな Web アプリを簡単に作成できます。したがって、React.js と Node.js を組み合わせてフル スタックの Web アプリを開発するのは、致命的な組み合わせです。

NPM (ノード パッケージ マネージャー) を使用すると、コマンドライン インターフェイス (CLI) を使用して任意のパッケージをインストールできます。さらに、Node は Webpack やその他のモジュールを使用して、React アプリケーションから簡単にコンパイルできる単一のファイルを作成します。

Node with React.js が好きな人は手を挙げてください!

React と Node.Js を使用してフルスタックの Web アプリを作成するのは致命的な組み合わせですか?

React と Node JS の統合を組み合わせることによる Web 開発は、より効率的で時間を節約できます。また、ビジネス オーナーは、ビジネスの他のより重要な部分に取り組むことができます。

フルスタック Web 開発を使用する理由を見てみましょう。

  • プロジェクトのスケーラビリティを向上

複雑なプロジェクトを構築する場合、スケーラビリティは企業にとって最も差し迫った懸念事項の 1 つです。アプリ開発者を雇って Node.js と React を一緒に使用すると、さまざまなデバイスで動作するインタラクティブで大規模なデータ駆動型の Web アプリを構築できます。

  • MERNスタックコンボ

MERN スタックは、MongoDB、Express、React、および Node.js で構成されています。Web サイトに独自の次元を提供するのにこれ以上の組み合わせはありません。MERN スタックは Node.js と React.js で動作するため、Node と React を組み合わせて Web アプリケーション開発を行うことができます。

  • アプリでのリアルタイム データ管理

Node.js は、ストリーミング データ アプリケーションを構築している場合やリアルタイム データを処理している場合に適しています。このタイプのアプリには継続的なサーバー接続が必要であり、Node.js はアプリの継続的なサポートを提供します。

  • より迅速な開発

React と Node.js を組み合わせることで、高い投資収益率を生み出し、費用と時間を節約できます。これらのテクノロジーは、迅速で効果的で保守が容易な Web サイトを構築するための理想的なプラットフォームを提供するからです。

  • 単一ページ アプリケーション (SPA)

非同期データ読み込みを備えたシングルページ アプリをお探しですか? その場合、コールバック関数を使用して軽量のバックエンド モデルを構築できるので、React with a Node バックエンドが最適です。

  • Web アプリのフロントエンド開発とバックエンド開発の両方に対応する単一の言語

Node と React を使用すると、開発者は Python や Ruby などのさまざまな複雑な言語を学習する必要がなくなります。サーバー側の開発には Node を使用し、フロントエンドには React を使用できます。資源、お金、時間の節約に加えて、このリサイクルは廃棄物を減らします。

  • JavaScript の過度の使用

Node with React は、フロントエンドとバックエンドの両方に JavaScript を提供します。これにより、Web サイトと Web アプリを作成するための自由度と柔軟性が向上します。開発者は、アプリ開発プロセス全体で JavaScript を単一の言語として使用できます。

簡単に言うと、Node.js と React を使用して Web アプリケーションを構築する場合は、React 開発者だけでなく Node.js 開発者も雇う必要があります。このようにして、両方のテクノロジーを効果的に使用することで、ビジネスに最適な Web アプリを作成できます。

この Node.JS と React.Js の組み合わせは、このようなビジネスにどのように役立つのでしょうか?

今日の競争の激しい市場で生き残るために、企業は顧客をターゲットにして、優れたユーザー エクスペリエンスを提供するソリューションを提供する必要があります。幸いなことに、React with Node.js は、強力な Web アプリをすばやく構築し、さまざまなデバイスで高レベルのパフォーマンスを維持できるプラットフォームを提供します。

大量のデータを処理できる最新の応答性の高い Web アプリを構築したい場合は、Node.js と React が最適なオプションです。試してみませんか?

React の設計モデルは単純であるため、再利用可能なコンポーネントを作成できます。また、Node.js のイベント駆動型アーキテクチャにより、大量のトラフィックをより高速に処理できます。

全体として、フルスタック Web アプリを開発するための致命的な組み合わせを選択することは、企業にとって価値のある決定です。この Node.js と React の組み合わせを使用すると、時間とお金を簡単に節約でき、ビジネスに競争力を加えることができます。

まとめ: React と Node.js を使用した強力なフルスタック アプリの開発

このブログの最後に、この 2 つのテクノロジはうまく連携できると言っても過言ではありません。Node.js は、効率的な速度でデータ処理を提供するサーバー側のプラットフォームであり、JavaScript で記述された Web サーバーの構築に使用できます。

React は、開発者が Javascript を使用してコンポーネントからインターフェイスを作成するのに役立つフロントエンド フレームワークです。Web アプリ開発者を雇うことで、これらの JS ライブラリをシームレスに組み合わせて強力な Web サイトを作成できます。

これらのフレームワークの堅牢な機能により、面倒で時間のかかる他のフレームワークを使用せずにアプリを構築できます。最終的にこのアイデアに便利になり、開発者の専門家チームを探している場合は、ここにクエリをドロップできます!

ソース: https://javascript.plainenglish.io/why-combine-react-with-node-js-for-full-stack-web-app-development-e7c29030f67

#fullstack #react #nodejs 

React と Node.js を組み合わせてフルスタックの Web アプリを開発する
Thai  Son

Thai Son

1660921320

Kết Hợp React Với Node.js để Phát Triển ứng Dụng Web Full-Stack

Khi nói đến việc xây dựng một ứng dụng web đầy đủ từ đầu, có thể khó hiểu cách tổ chức mã của bạn theo cách hiệu quả nhất có thể. Nếu bạn đã từng sử dụng các ứng dụng web tiến bộ như Netflix hoặc Prime Videos, thì bạn chắc chắn biết giao diện đơn giản của chúng được bao bọc trong các tính năng phức tạp và được hỗ trợ bởi tính năng phụ trợ mạnh mẽ của chúng như thế nào.

Trong khi phát triển một ứng dụng web như Netflix, cơ sở dữ liệu của bạn nên làm một việc, hệ thống định tuyến của bạn nên làm một việc khác và logic kinh doanh của bạn nên quan tâm đến một số khía cạnh của ứng dụng của bạn cùng một lúc - nhưng làm thế nào để tất cả kết hợp lại với nhau?

Vì vậy, tóm lại, phát triển một ứng dụng web là tạo ra một giao diện người dùng đẹp mắt để thu hút người dùng của bạn tương tác với một ứng dụng. Và điều thứ hai là phát triển một chương trình phụ trợ mạnh mẽ giúp ứng dụng của bạn hoạt động trơn tru.

Trong bài viết này, chúng ta sẽ xem xét cách tạo toàn bộ ứng dụng web từ đầu bằng React và Node. Js - hai công cụ mạnh mẽ trong JavaScript. Nhưng trước khi bạn bắt đầu đọc blog này, đây là một số câu hỏi thường trực trong đầu bạn:

  • Tại sao React và Node.js là một lựa chọn phổ biến để phát triển Frontend và Backend?
    - React và Node.Js: Hiểu đường cơ sở, Ưu điểm và Trường hợp sử dụng của nó
  • Chúng ta có thể sử dụng Node.Js với React để phát triển ứng dụng web không?
  • Sử dụng React và Node.Js có phải là sự kết hợp chết người để tạo ra một ứng dụng web toàn ngăn xếp không?
  • Sự kết hợp Node.JS và React.Js này có thể mang lại lợi ích như thế nào cho các doanh nghiệp như vậy?
  • Kết luận: Phát triển một ứng dụng toàn ngăn xếp mạnh mẽ với React.js và Node.js

Hãy đi sâu vào chi tiết của từng điểm…

Tại sao React và Node.js là một lựa chọn phổ biến để phát triển Frontend và Backend?

Kết luận: Thư viện JavaScript React, thường được sử dụng trên giao diện người dùng, có thể tạo giao diện người dùng hấp dẫn. Ngược lại, Node.js, thường được sử dụng trên máy chủ, có thể tạo ra các ứng dụng có thể mở rộng. Kết hợp React và Node.js sẽ cực kỳ có lợi cho các nhà phát triển xây dựng các ứng dụng web full-stack.

React và Node.Js: Hiểu đường cơ sở, Ưu điểm và Trường hợp sử dụng của nó

Giới thiệu về React.JS (Thư viện JS Front-end)

ReactJS là một trong những thư viện JavaScript front-end phổ biến nhất cho phép các nhà phát triển xây dựng các ứng dụng web lớn với chế độ xem động, theo hướng dữ liệu bằng cách tạo các phần tử giao diện người dùng có thể sử dụng lại. Hơn nữa, nó có khả năng phản hồi và chức năng mượt mà trên nhiều thiết bị.

Nguồn hình ảnh

Theo Statista, React.js là một trong những framework web phổ biến nhất nhưng được sử dụng rộng rãi cho phép các nhà phát triển thiết kế các ứng dụng web có khả năng mở rộng và thuyết phục cao mà không cần kiến ​​thức về các framework hoặc ngôn ngữ lập trình phức tạp. Vì React.js được WhatsApp, Instagram, Netflix, Airbnb, v.v. tin cậy.

Điểm nổi bật chính của ReactJS

  • React là một khung JS front-end thân thiện với SEO.
  • Nó đi kèm với tài liệu và hướng dẫn chi tiết giúp người mới bắt đầu bắt đầu dự án.
  • Nó nâng cao hiệu suất ứng dụng vì nó sử dụng Virtual DOM.
  • Nó cung cấp hỗ trợ cho một số thành phần để xây dựng ứng dụng web và nâng cao quy trình phát triển ứng dụng web động.

Các tính năng chính của React.js

  • Dễ dàng truy cập và bảo trì hơn nhiều
  • Đảm bảo hiệu suất ứng dụng xuất sắc
  • Cung cấp mã ổn định
  • Lý tưởng để phát triển giao diện ứng dụng web

Các trường hợp sử dụng của React.js

  • Xây dựng ứng dụng trang đơn (SPA)
  • Tạo giao diện người dùng liền mạch
  • Ứng dụng duyệt web
  • Lý tưởng để xây dựng các trang web truyền thông xã hội lớn
  • Thư viện động

Để sử dụng toàn diện React.js trong phát triển ứng dụng web, bạn nên thuê một nhà phát triển React làm việc cho công ty phát triển web React hàng đầu. Tận dụng kiến ​​thức chuyên môn và kinh nghiệm phát triển ứng dụng với React, họ có thể giúp bạn tạo một ứng dụng web thành công.

Giới thiệu về Node.JS (Thư viện JS Back-end)

Node.js được tạo bằng công cụ JavaScript V8 của Google. Đó là một ngôn ngữ lập trình mã nguồn mở có thể chạy trên nhiều nền tảng và giảm đáng kể thời gian phát triển. Không cần sao chép khi sử dụng ngôn ngữ JS và các mô-đun với sự trợ giúp của Node.js.

Theo thống kê , trong số hơn 63.000 trang web được kiểm tra ở Mỹ, hơn 37.000 trang web đang chạy trên Node.js.”

Nếu bạn đang thắc mắc tại sao Node.js lại được sử dụng rộng rãi để phát triển phần phụ trợ của ứng dụng web và tại sao bạn nên thuê một nhà phát triển ứng dụng Node để phát triển ứng dụng? Chà, trước khi bạn tin tưởng vào dữ liệu này, ở đây chúng tôi sẽ giải thích cho bạn những lý do và lợi thế hợp lệ của Node.js:

Ưu điểm của Node.Js

  • Nó có thể được sử dụng cho cả ứng dụng phía máy chủ và phía máy khách.
  • Dựa trên công cụ V8 JS của Chrome, Node có thể cải thiện 50% hiệu suất ứng dụng của bạn.
  • Các hoạt động I / O không chặn sẽ sao lưu môi trường thời gian chạy của nó, vì vậy nó cho phép thực thi mã hiệu quả.
  • Node cung cấp khả năng mở rộng tốt hơn so với các máy chủ JS khác. Nó hỗ trợ mở rộng quy mô theo cả chiều dọc và chiều ngang.

Các tính năng của Node.Js

  • Không chặn, không đồng bộ và phụ thuộc vào sự kiện xảy ra
  • Có thể mở rộng nhưng chưa đọc
  • Tốt hơn là theo dõi nhanh quá trình phát triển.
  • Khả năng tương thích với các thiết bị khác nhau
  • Truyền dữ liệu nhanh chóng mà không có bộ đệm
  • Phát triển mã nhanh chóng
  • Dựa trên JavaScript

Các trường hợp sử dụng của Node.Js

  • Ứng dụng web thời gian thực
  • Truyền dữ liệu
  • SPA (Ứng dụng trang đơn) phức tạp
  • Proxy trên máy chủ

Node.js là một trong những thư viện JavaScript mạnh nhất có thể giúp bạn xây dựng một chương trình phụ trợ mạnh mẽ. Bạn có thể thuê các nhà phát triển Node.js tại một công ty phát triển web Node.js xuất sắc để sử dụng các tính năng và chức năng chính của Node.js.

Có thể sử dụng Node.JS với React để phát triển ứng dụng web không?

Đúng rồi. Node.js tạo điều kiện thuận lợi cho việc tạo các API RESTful back-end có khả năng mở rộng và nhanh chóng. Mặt khác, React là một thư viện front-end tạo ra các giao diện người dùng tương tác. Với cả hai công cụ này, bạn có thể tạo các ứng dụng web phức tạp và có thể mở rộng mà không cần nỗ lực nhiều. Do đó, sử dụng React.js với Node.js để phát triển ứng dụng web đầy đủ là một sự kết hợp chết người.

Với NPM (Node Package Manager), bạn có thể cài đặt bất kỳ gói nào với giao diện dòng lệnh (CLI). Ngoài ra, Node sử dụng Webpack và các mô-đun khác để tạo một tệp đơn có thể biên dịch dễ dàng từ một ứng dụng React.

Hãy giơ tay lên nếu bạn thích Node với React.js!

Sử dụng React và Node.Js có phải là sự kết hợp chết người để tạo ra một ứng dụng web toàn ngăn xếp không?

Phát triển web bằng cách kết hợp tích hợp React và Node JS hiệu quả hơn và tiết kiệm thời gian hơn. Nó cũng cho phép các chủ doanh nghiệp làm việc trên các bộ phận khác, quan trọng hơn trong công việc kinh doanh của họ.

Hãy xem những lý do tại sao bạn có thể muốn sử dụng phát triển web đầy đủ.

  • Tăng khả năng mở rộng dự án

Khi nói đến việc xây dựng các dự án phức tạp, khả năng mở rộng là một trong những mối quan tâm cấp bách nhất đối với các doanh nghiệp. Khi sử dụng Node.js và React cùng nhau bằng cách thuê một nhà phát triển ứng dụng , họ có thể xây dựng các ứng dụng web tương tác và dựa trên dữ liệu lớn hoạt động trên nhiều loại thiết bị.

  • Tổ hợp ngăn xếp MERN

MERN Stack được tạo thành từ MongoDB, Express, React và Node.js. Không có sự kết hợp nào tốt hơn để cung cấp một trang web với kích thước duy nhất của nó. MERN Stack hoạt động với Node.js và React.js, vì vậy Node và React có thể được kết hợp để phát triển ứng dụng web.

  • Quản lý dữ liệu thời gian thực trong ứng dụng

Node.js là một lựa chọn tốt nếu bạn đang xây dựng một ứng dụng dữ liệu trực tuyến hoặc xử lý dữ liệu thời gian thực. Loại ứng dụng này yêu cầu kết nối máy chủ liên tục và Node.js cung cấp hỗ trợ liên tục cho ứng dụng của bạn.

  • Phát triển nhanh hơn

Kết hợp React với Node có thể tạo ra lợi tức đầu tư cao và giúp bạn tiết kiệm cả tiền bạc và thời gian vì những công nghệ này cung cấp một nền tảng lý tưởng để xây dựng các trang web nhanh chóng, hiệu quả và dễ bảo trì.

  • Ứng dụng trang đơn (SPA)

Bạn đang tìm kiếm một ứng dụng một trang có tải dữ liệu không đồng bộ? Nếu vậy, React với Node back-end là cách để đi, vì nó cho phép bạn xây dựng một mô hình back-end nhẹ với các chức năng gọi lại.

  • Một ngôn ngữ cho cả phát triển mặt trước và mặt sau của ứng dụng web

Với việc sử dụng Node và React, các nhà phát triển không phải học các ngôn ngữ phức tạp khác nhau như Python hoặc Ruby. Họ chỉ có thể sử dụng Node cho phía máy chủ phát triển và React cho giao diện người dùng. Ngoài việc tiết kiệm tài nguyên, tiền bạc và thời gian, việc tái chế này còn giảm thiểu chất thải.

  • Sử dụng quá nhiều JavaScript

Node with React cung cấp JavaScript cho cả front end và back end và điều này mang lại sự tự do và linh hoạt hơn để tạo các trang web và ứng dụng web. Các nhà phát triển có thể sử dụng JavaScript như một ngôn ngữ duy nhất cho toàn bộ quá trình phát triển ứng dụng.

Tóm lại: Nếu bạn quyết định sử dụng Node.js và React để xây dựng một ứng dụng web, bạn nên thuê các nhà phát triển Node.js cũng như các nhà phát triển React. Bằng cách này, bạn sẽ sử dụng hiệu quả cả hai công nghệ, từ đó hình thành các ứng dụng web tuyệt vời cho doanh nghiệp của bạn.

Sự kết hợp Node.JS và React.Js này có thể mang lại lợi ích như thế nào cho các doanh nghiệp như vậy?

Để tồn tại trong thị trường cạnh tranh ngày nay, các doanh nghiệp phải nhắm đến khách hàng của mình và cung cấp cho họ một giải pháp mang lại trải nghiệm người dùng tuyệt vời. May mắn thay, React with Node.js cung cấp một nền tảng cho phép bạn xây dựng các ứng dụng web mạnh mẽ một cách nhanh chóng và duy trì mức hiệu suất cao trên một số thiết bị.

Đối với những người muốn xây dựng các ứng dụng web hiện đại, đáp ứng có thể xử lý lượng lớn dữ liệu, Node.js và React là những lựa chọn tuyệt vời. Hãy thử xem sao?

Sự đơn giản trong mô hình thiết kế của React cho phép tạo ra các thành phần có thể tái sử dụng, trong khi kiến ​​trúc hướng sự kiện của Node.js giúp nó có thể xử lý khối lượng lớn lưu lượng truy cập với tốc độ nhanh hơn.

Tất cả trong tất cả việc lựa chọn sự kết hợp chết người để phát triển các ứng dụng web full-stack sẽ là một quyết định đáng cân nhắc cho các doanh nghiệp. Họ có thể dễ dàng tiết kiệm thời gian và tiền bạc bằng cách sử dụng sự kết hợp Node.js và React này và có thể thêm lợi thế cạnh tranh cho doanh nghiệp của họ.

Kết luận: Phát triển một ứng dụng Full-Stack mạnh mẽ với React và Node.js

Ở phần cuối của blog này, đủ công bằng để nói rằng hai công nghệ này có thể hoạt động tốt cùng nhau. Node.js là một nền tảng phía máy chủ cung cấp khả năng xử lý dữ liệu với tốc độ hiệu quả và có thể được sử dụng để xây dựng các máy chủ web được viết bằng JavaScript.

React là một khung công tác front-end giúp các nhà phát triển tạo giao diện từ các thành phần sử dụng Javascript. Bằng cách thuê một nhà phát triển ứng dụng web , bạn có thể kết hợp liền mạch các thư viện JS này để tạo một trang web mạnh mẽ.

Khả năng mạnh mẽ của các khung công tác này có thể giúp bạn xây dựng một ứng dụng mà không cần sử dụng các khung công tác khác gây phiền hà và tốn thời gian. Vì vậy, nếu cuối cùng bạn đã thuận tiện với ý tưởng và tìm kiếm một nhóm chuyên gia của các nhà phát triển thì tại đây, bạn có thể thả một truy vấn bên dưới!

Nguồn: https://javascript.plainenglish.io/why-combine-react-with-node-js-for-full-stack-web-app-development-e7c29030f67

#fullstack #react #nodejs 

Kết Hợp React Với Node.js để Phát Triển ứng Dụng Web Full-Stack
郝 玉华

郝 玉华

1660921221

结合 React 和 Node.js 进行全栈 Web 应用开发

从头开始构建全栈 Web 应用程序时,可能很难理解如何以最有效的方式组织代码。如果您曾经使用过 Netflix 或 Prime Videos 等渐进式 Web 应用程序,那么您肯定知道它们的简单界面是如何被复杂的功能所包裹并由其强大的后端赋予的。

在开发像 Netflix 这样的 Web 应用程序时,您的数据库应该做一件事,您的路由系统应该做另一件事,而您的业务逻辑应该同时处理应用程序的某些方面——但是这一切是如何结合在一起的呢?

因此,简而言之,开发 Web 应用程序就是要创建一个漂亮的前端,让您的用户与应用程序保持互动。第二件事是开发一个强大的后端,使您的应用程序运行顺畅。

在本文中,我们将了解如何使用 React 和 Node 从头开始​​构建整个 Web 应用程序。Js — JavaScript 中的两个强大工具。但在你开始阅读这篇博客之前,这里有几个问题一直萦绕在你的脑海中:

  • 为什么 React 和 Node.js 是开发前端和后端的热门选择?
    - React 和 Node.Js:了解它的基线、优点和用例
  • 我们可以将 Node.Js 与 React 一起用于 Web 应用程序开发吗?
  • 使用 React 和 Node.Js 是创建全栈 Web 应用程序的致命组合吗?
  • Node.JS 和 React.Js 的这种组合如何使这些企业受益?
  • 结论:使用 React.js 和 Node.js 开发强大的全栈应用程序

让我们深入挖掘每个点的细节......

为什么 React 和 Node.js 是开发前端和后端的热门选择?

结论: JavaScript 库 React,通常用于前端,可以创建有吸引力的用户界面。相比之下,经常在服务器上使用的 Node.js 可以创建可扩展的应用程序。将 React 和 Node.js 结合起来对于构建全栈 Web 应用程序的开发人员来说将是非常有益的。

React 和 Node.Js:了解它的基线、优点和用例

React.JS(前端 JS 库)简介

ReactJS 是最流行的前端 JavaScript 库之一,它使开发人员能够通过创建可重用的 UI 元素来构建具有数据驱动的动态视图的大型 Web 应用程序。此外,它还具有跨多个设备的流畅响应和功能。

图片来源

根据 Statista 的说法,React.js 是最流行但使用最广泛的 Web 框架之一,它允许开发人员设计具有高度说服力和可扩展性的 Web 应用程序,而无需了解复杂的框架或编程语言。由于 React.js 受到 WhatsApp、Instagram、Netflix、Airbnb 等的信任。

ReactJS 的主要亮点

  • React 是一个对 SEO 友好的前端 JS 框架。
  • 它附带详细的文档和教程,可帮助初学者快速启动项目。
  • 它使用虚拟 DOM 提高了应用程序的性能。
  • 它为构建 Web 应用程序的多个组件提供支持,并增强了动态 Web 应用程序开发过程。

React.js 的主要特点

  • 它更容易访问和维护
  • 确保出色的应用性能
  • 提供稳定的代码
  • 非常适合开发 Web 应用程序前端

React.js 的用例

  • 构建单页应用程序 (SPA)
  • 创建无缝的用户界面
  • 网页浏览应用
  • 非常适合构建大型社交媒体网站
  • 动态库

为了在 Web 应用程序开发中全面使用 React.js,值得聘请为领先的 React Web 开发公司工作的 React 开发人员。利用使用 React 开发应用程序的专业知识和经验,他们可以帮助您创建成功的 Web 应用程序。

Node.JS(后端 JS 库)简介

Node.js 是使用 Google 的 V8 JavaScript 引擎创建的。它是一种开源编程语言,可以在多个平台上运行并显着减少开发时间。在 Node.js 的帮助下使用 JS 语言和模块时无需重复。

据统计,在美国超过 63,000 个被检查的网站中,有超过 37,000 个网站在 Node.js 上运行。”

如果您想知道为什么 Node.js 被广泛用于 Web 应用程序的后端开发,以及为什么您应该聘请 Node 应用程序开发人员进行应用程序开发?好吧,在您相信这些数据之前,我们在这里向您描述 Node.js 的正当理由和优势:

Node.Js 的优势

  • 它可用于服务器端和客户端应用程序。
  • 基于 Chrome 的 V8 JS 引擎,Node 可以将您的应用程序的性能提高 50%。
  • 非阻塞 I/O 操作支持其运行时环境,因此它可以实现高效的代码执行。
  • Node 提供了比其他 JS 服务器更好的可扩展性。它支持垂直和水平缩放。

Node.Js 的特点

  • 无阻塞、异步、依赖事件发生
  • 可扩展但无线程
  • 最好快速跟踪开发过程。
  • 与不同设备的兼容性
  • 无缓冲的快速数据流
  • 快速代码开发
  • 基于 JavaScript

Node.Js 的用例

  • 实时网络应用
  • 数据流
  • 复杂的 SPA(单页应用程序)
  • 服务器上的代理

Node.js 是最强大的 JavaScript 库之一,可以帮助您构建强大的后端。您可以在优秀的 Node.js Web 开发公司聘请 Node.js 开发人员来利用 Node.js 的关键特性和功能。

是否可以将 Node.JS 与 React 一起用于 Web 应用程序开发?

这是正确的。Node.js 有助于创建可扩展且快速的后端 RESTful API。另一方面,React 是一个产生交互式用户界面的前端库。使用这两种工具,您可以轻松创建复杂且可扩展的 Web 应用程序。因此,使用 React.js 和 Node.js 进行全栈 Web 应用程序开发是一种致命的组合。

使用 NPM(节点包管理器),您可以使用命令行界面 (CLI) 安装任何包。此外,Node 使用 Webpack 和其他模块从 React 应用程序创建一个易于编译的单个文件。

如果你喜欢 Node 和 React.js,请举手!

使用 React 和 Node.Js 是创建全栈 Web 应用程序的致命组合吗?

通过结合 React 和 Node JS 集成的 Web 开发更高效,更节省时间。它还允许企业主处理其业务中其他更重要的部分。

让我们看看您可能想要使用全栈 Web 开发的原因。

  • 提高项目可扩展性

在构建复杂项目时,可扩展性是企业最紧迫的问题之一。通过聘请应用程序开发人员将 Node.js 和 React 一起使用时,他们可以构建可在各种设备上运行的交互式和大型数据驱动的 Web 应用程序。

  • MERN 堆栈组合

MERN 堆栈由 MongoDB、Express、React 和 Node.js 组成。没有更好的组合可以为网站提供其独特的维度。MERN 堆栈与 Node.js 和 React.js 一起使用,因此可以结合使用 Node 和 React 进行 Web 应用程序开发。

  • 应用程序中的实时数据管理

如果您正在构建流数据应用程序或处理实时数据,Node.js 是一个不错的选择。这种类型的应用程序需要持续的服务器连接,Node.js 为您的应用程序提供持续支持。

  • 更快的发展

将 React 与 Node 相结合可以产生高投资回报并为您节省金钱和时间,因为这些技术为构建快速、有效且易于维护的网站提供了理想平台。

  • 单页应用程序 (SPA)

您是否正在寻找具有异步数据加载的单页应用程序?如果是这样,使用 Node 后端的 React 是不错的选择,因为它使您能够构建带有回调函数的轻量级后端模型。

  • Web App前端和后端开发的单一语言

使用 Node 和 React,开发人员不必学习 Python 或 Ruby 等各种复杂的语言。他们可以只将 Node 用于开发的服务器端,而将 React 用于前端。除了节省资源、金钱和时间之外,这种回收还减少了浪费。

  • 过度使用 JavaScript

Node with React 为前端和后端提供了 JavaScript,这为创建网站和 Web 应用程序提供了更多的自由和灵活性。开发人员可以在整个应用程序开发过程中使用 JavaScript 作为单一语言。

简而言之:如果您决定使用 Node.js 和 React 来构建 Web 应用程序,您应该雇佣 Node.js 开发人员以及 React 开发人员。通过这种方式,您将有效地使用这两种技术,从而为您的业务构建出色的 Web 应用程序。

Node.JS 和 React.Js 的这种组合如何使这些企业受益?

为了在当今竞争激烈的市场中生存,企业必须瞄准他们的客户并为他们提供能够提供出色用户体验的解决方案。幸运的是,React with Node.js 提供了一个平台,可让您快速构建强大的 Web 应用程序并在多种设备上保持高水平的性能。

对于那些希望构建可以处理大量数据的现代响应式 Web 应用程序的人来说,Node.js 和 React 是不错的选择。为什么不试试呢?

React 设计模型的简单性允许创建可重用的组件,而 Node.js 的事件驱动架构使得以更快的速度处理大量流量成为可能。

总而言之,选择致命的组合来开发全栈 Web 应用程序对于企业来说将是一个值得的决定。他们可以使用这种 Node.js 和 React 组合轻松节省时间和金钱,并能够为他们的业务增加竞争优势。

结论:使用 React 和 Node.js 开发强大的全栈应用程序

在这篇博客的最后,可以公平地说这两种技术可以很好地协同工作。Node.js 是一个服务器端平台,以高效的速度提供数据处理,可用于构建用 JavaScript 编写的 Web 服务器。

React 是一个前端框架,可帮助开发人员使用 Javascript 从组件创建接口。通过聘请 Web 应用开发人员,您可以无缝组合这些 JS 库来创建强大的网站。

这些框架的强大功能可以帮助您构建应用程序,而无需使用麻烦且耗时的其他框架。因此,如果您最终对这个想法感到方便并正在寻找一个专家级的开发人员团队,那么您可以在下面进行查询!

来源:https ://javascript.plainenglish.io/why-combine-react-with-node-js-for-full-stack-web-app-development-e7c29030f67

#fullstack #react #nodejs 

结合 React 和 Node.js 进行全栈 Web 应用开发
Mélanie  Faria

Mélanie Faria

1660921200

Combine React Com Node.js Para Desenvolvimento De Aplicativos Web De P

Quando se trata de criar um aplicativo da Web full-stack do zero, pode ser difícil entender como organizar seu código da maneira mais eficaz possível. Se você já usou aplicativos da web progressivos como Netflix ou Prime Videos, certamente sabe como sua interface simples é envolvida em recursos complexos e capacitada por seu forte back-end.

Ao desenvolver um aplicativo da Web como o Netflix, seu banco de dados deve fazer uma coisa, seu sistema de roteamento deve fazer outra e sua lógica de negócios deve cuidar de algum aspecto do seu aplicativo de uma só vez - mas como tudo isso se encaixa?

Portanto, em poucas palavras, desenvolver um aplicativo da Web é criar um belo frontend que mantenha seus usuários envolvidos com um aplicativo. E a segunda coisa é desenvolver um back-end forte que faça seu aplicativo funcionar sem problemas.

Neste artigo, veremos como criar um aplicativo Web inteiro do zero usando React e Node. Js — duas ferramentas poderosas em JavaScript. Mas antes de começar a ler este blog, aqui estão algumas perguntas que ficam em sua mente:

  • Por que React e Node.js são uma escolha popular para desenvolver front-end e back-end?
    - React e Node.Js: Entendendo sua linha de base, prós e casos de uso
  • Podemos usar o Node.Js com o React para o desenvolvimento de aplicativos da Web?
  • O uso de React e Node.Js é uma combinação mortal para criar um aplicativo Web Full-Stack?
  • Como essa combinação de Node.JS e React.Js pode beneficiar essas empresas?
  • Conclusão: desenvolvendo um aplicativo full-stack poderoso com React.js e Node.js

Vamos nos aprofundar nos detalhes de cada ponto…

Por que React e Node.js são uma escolha popular para desenvolver front-end e back-end?

Conclusão: A biblioteca JavaScript React, que normalmente é usada no front-end, pode criar interfaces de usuário atraentes. Por outro lado, o Node.js, que geralmente é usado no servidor, pode criar aplicativos escalonáveis. A combinação de React e Node.js será extremamente benéfica para desenvolvedores que criam aplicativos web full-stack.

React e Node.Js: Entendendo sua linha de base, prós e casos de uso

Uma introdução ao React.JS (Biblioteca JS Front-end)

O ReactJS é uma das bibliotecas JavaScript de front-end mais populares que permite que os desenvolvedores criem grandes aplicativos da Web com visualizações dinâmicas e orientadas por dados, criando elementos de interface do usuário reutilizáveis. Além disso, possui capacidade de resposta e funcionalidade suaves em vários dispositivos.

Fonte da imagem

De acordo com Statista, o React.js é um dos frameworks web mais populares e amplamente utilizados que permite aos desenvolvedores projetar aplicativos web altamente convincentes e escaláveis ​​sem ter conhecimento de frameworks complexos ou linguagens de programação. Como o React.js é confiável para WhatsApp, Instagram, Netflix, Airbnb e muito mais.

Principais destaques do ReactJS

  • O React é um framework JS de front-end amigável para SEO.
  • Ele vem com documentação detalhada e tutoriais que ajudam os iniciantes a iniciar o projeto.
  • Ele melhora o desempenho do aplicativo, pois usa o Virtual DOM.
  • Ele oferece suporte para vários componentes para a criação de aplicativos da Web e aprimora o processo de desenvolvimento dinâmico de aplicativos da Web.

Principais recursos do React.js

  • É muito mais fácil acessar e manter
  • Garanta um excelente desempenho do aplicativo
  • Ofereça um código estável
  • Ideal para desenvolver front-end de aplicativos da web

Casos de uso do React.js

  • Como criar aplicativos de página única (SPAs)
  • Criando interfaces de usuário perfeitas
  • Aplicativos de navegação na web
  • Ideal para construir grandes sites de mídia social
  • Bibliotecas dinâmicas

Para fazer uso abrangente do React.js no desenvolvimento de aplicativos web, vale a pena contratar um desenvolvedor React trabalhando para a empresa líder em desenvolvimento web React. Aproveitando o conhecimento e a experiência de desenvolvimento de um aplicativo com o React, eles podem ajudá-lo a criar um aplicativo da web de sucesso.

Uma introdução ao Node.JS (Biblioteca JS de back-end)

O Node.js é criado com o mecanismo JavaScript V8 do Google. É uma linguagem de programação de código aberto que pode ser executada em várias plataformas e reduzir significativamente o tempo de desenvolvimento. Não há necessidade de duplicação ao usar a linguagem JS e módulos com a ajuda do Node.js.

De acordo com as estatísticas , dos mais de 63.000 sites verificados nos EUA, mais de 37.000 sites estão sendo executados em Node.js.”

Se você está se perguntando por que o Node.js é amplamente usado para o desenvolvimento de back-end do aplicativo da Web e por que você deve contratar um desenvolvedor de aplicativo Node para o desenvolvimento do aplicativo? Bem, antes que você confie nesses dados, aqui estamos mostrando as razões e vantagens válidas do Node.js:

Vantagens do Node.Js

  • Ele pode ser usado para aplicativos do lado do servidor e do lado do cliente.
  • Com base no mecanismo V8 JS do Chrome, o Node pode melhorar o desempenho do seu aplicativo em 50%.
  • As operações de E/S sem bloqueio fazem backup de seu ambiente de tempo de execução, permitindo a execução eficiente de código.
  • O Node oferece melhor escalabilidade do que outros servidores JS. Ele suporta dimensionamento vertical e horizontal.

Recursos do Node.Js

  • Sem bloqueio, assíncrono e dependente de ocorrências de eventos
  • Escalável, mas não encadeado
  • É melhor acelerar o processo de desenvolvimento.
  • Compatibilidade com vários dispositivos
  • Streaming de dados rápido sem buffer
  • Desenvolvimento de código rápido
  • Baseado em JavaScript

Casos de uso de Node.Js

  • Aplicações web em tempo real
  • Transmissão de dados
  • SPAs (Single Page Applications) que são complexos
  • Proxies no servidor

O Node.js é uma das bibliotecas JavaScript mais fortes que podem ajudar você a criar um back-end poderoso. Você pode contratar desenvolvedores Node.js em uma excelente empresa de desenvolvimento web Node.js para fazer uso dos principais recursos e funcionalidades do Node.js.

É possível usar o Node.JS com o React para desenvolvimento de aplicativos da Web?

Está correto. O Node.js facilita a criação de APIs RESTful de back-end que são escaláveis ​​e rápidas. Por outro lado, React é uma biblioteca front-end que produz interfaces de usuário interativas. Com ambas as ferramentas, você pode criar aplicativos Web complexos e escaláveis ​​com pouco esforço. Portanto, usar React.js com Node.js para o desenvolvimento de aplicativos web full stack é uma combinação mortal.

Com o NPM (Node Package Manager), você pode instalar qualquer pacote com a interface de linha de comando (CLI). Além disso, o Node usa o Webpack e outros módulos para criar um único arquivo facilmente compilável a partir de um aplicativo React.

Levante a mão se você gosta de Node com React.js!

O uso de React e Node.Js é uma combinação mortal para criar um aplicativo Web Full-Stack?

O desenvolvimento da Web combinando a integração React e Node JS é mais eficiente e economiza tempo. Também permite que os empresários trabalhem em outras partes mais importantes de seus negócios.

Vejamos as razões pelas quais você pode querer usar o desenvolvimento web full-stack.

  • Aumenta a escalabilidade do projeto

Quando se trata de construir projetos complexos, a escalabilidade é uma das preocupações mais prementes para as empresas. Ao usar o Node.js e o React juntos contratando um desenvolvedor de aplicativos , eles podem criar aplicativos da Web interativos e grandes baseados em dados que funcionam em vários dispositivos.

  • Combinação de Pilha MERN

A pilha MERN é composta por MongoDB, Express, React e Node.js. Não há melhor combinação para dar a um website a sua dimensão única. O MERN Stack funciona com Node.js e React.js, então Node e React podem ser combinados para o desenvolvimento de aplicações web.

  • Gerenciamento de dados em tempo real em aplicativos

O Node.js é uma boa escolha se você estiver criando um aplicativo de dados de streaming ou manipulando dados em tempo real. Esse tipo de aplicativo requer uma conexão de servidor contínua e o Node.js fornece suporte constante para seu aplicativo.

  • Desenvolvimento mais rápido

A combinação do React com o Node pode gerar um alto retorno sobre o investimento e economizar dinheiro e tempo, pois essas tecnologias fornecem uma plataforma ideal para criar sites rápidos, eficazes e fáceis de manter.

  • Aplicativos de página única (SPA)

Você está procurando um aplicativo de página única com carregamento de dados assíncrono? Nesse caso, React with a Node back-end é o caminho a seguir, pois permite que você crie um modelo de back-end leve com funções de retorno de chamada.

  • Linguagem única para desenvolvimento de front e back-end de aplicativos da Web

Com o uso de Node e React, os desenvolvedores não precisam aprender várias linguagens complexas, como Python ou Ruby. Eles podem apenas usar o Node para o lado do servidor de desenvolvimento e o React para o front-end. Além de economizar recursos, dinheiro e tempo, essa reciclagem reduz o desperdício.

  • Uso excessivo de JavaScript

O Node com React fornece JavaScript para front e back end, e isso oferece mais liberdade e flexibilidade para criar sites e aplicativos da web. Os desenvolvedores podem usar JavaScript como uma linguagem única para todo o processo de desenvolvimento de aplicativos.

Em poucas palavras: Se você decidir usar Node.js e React para construir uma aplicação web, você deve contratar desenvolvedores Node.js assim como desenvolvedores React. Dessa forma, você utilizará efetivamente ambas as tecnologias, formando excelentes aplicativos web para o seu negócio.

Como essa combinação de Node.JS e React.Js pode beneficiar essas empresas?

Para sobreviver no mercado competitivo de hoje, as empresas devem segmentar seus clientes e fornecer a eles uma solução que ofereça uma ótima experiência ao usuário. Felizmente, o React with Node.js fornece uma plataforma que permite criar aplicativos da Web poderosos rapidamente e manter um alto nível de desempenho em vários dispositivos.

Para aqueles que desejam criar aplicativos da Web modernos e responsivos que podem lidar com grandes quantidades de dados, o Node.js e o React são ótimas opções. Por que não experimentá-lo?

A simplicidade do modelo de design do React permite a criação de componentes reutilizáveis, enquanto a arquitetura orientada a eventos do Node.js possibilita lidar com grandes volumes de tráfego em uma taxa mais rápida.

Em suma, escolher a combinação mortal para desenvolver aplicativos da Web full-stack será uma decisão que vale a pena para as empresas. Eles podem economizar tempo e dinheiro facilmente usando essa combinação de Node.js e React e podem adicionar uma vantagem competitiva aos seus negócios.

Conclusão: desenvolvendo um aplicativo full-stack poderoso com React e Node.js

No final deste blog, é justo dizer que essas duas tecnologias podem funcionar bem juntas. Node.js é uma plataforma do lado do servidor que fornece manipulação de dados em uma velocidade eficiente e pode ser usada para construir servidores web escritos em JavaScript.

React é um framework front-end que ajuda os desenvolvedores a criar interfaces a partir de componentes usando Javascript. Ao contratar um desenvolvedor de aplicativos da Web , você pode combinar perfeitamente essas bibliotecas JS para criar um site poderoso.

Os recursos robustos dessas estruturas podem ajudá-lo a criar um aplicativo sem o uso de outras estruturas problemáticas e demoradas. Então, se você finalmente tiver conveniência com a ideia e estiver procurando por uma equipe especializada de desenvolvedores, aqui você pode fazer uma consulta abaixo!

Fonte: https://javascript.plainenglish.io/why-combine-react-with-node-js-for-full-stack-web-app-development-e7c29030f67

#fullstack #react #nodejs 

Combine React Com Node.js Para Desenvolvimento De Aplicativos Web De P

Combinez React avec Node.js pour le développement d'applications Web à

Lorsqu'il s'agit de créer une application Web complète à partir de zéro, il peut être difficile de comprendre comment organiser votre code de la manière la plus efficace possible. Si vous avez déjà utilisé des applications Web progressives telles que Netflix ou Prime Videos, vous savez sûrement comment leur interface simple est enveloppée de fonctionnalités complexes et renforcée par leur puissant backend.

Lors du développement d'une application Web telle que Netflix, votre base de données doit faire une chose, votre système de routage doit en faire une autre et votre logique métier doit prendre en charge certains aspects de votre application en même temps. Mais comment tout cela s'articule-t-il ?

Donc, en un mot, développer une application Web consiste à créer une belle interface qui maintient vos utilisateurs engagés avec une application. Et la deuxième chose est de développer un backend solide qui permet à votre application de fonctionner en douceur.

Dans cet article, nous verrons comment créer une application Web complète à partir de zéro en utilisant React et Node. Js — deux outils puissants en JavaScript. Mais avant de commencer à lire ce blog, voici quelques questions qui vous restent à l'esprit :

  • Pourquoi React et Node.js sont un choix populaire pour le développement de frontend et de backend ?
    - React et Node.Js : comprendre sa ligne de base, ses avantages et ses cas d'utilisation
  • Pouvons-nous utiliser Node.Js avec React pour le développement d'applications Web ?
  • L'utilisation de React et Node.Js est-elle une combinaison mortelle pour créer une application Web Full-Stack ?
  • Comment cette combinaison de Node.JS et React.Js peut-elle bénéficier à ces entreprises ?
  • Conclusion : Développer une puissante application Full-Stack avec React.js et Node.js

Approfondissons les détails de chaque point…

Pourquoi React et Node.js sont un choix populaire pour le développement de frontend et de backend ?

Conclusion : la bibliothèque JavaScript React, qui est généralement utilisée sur le front-end, peut créer des interfaces utilisateur attrayantes. En revanche, Node.js, qui est souvent utilisé sur le serveur, peut créer des applications évolutives. La combinaison de React et Node.js sera extrêmement bénéfique pour les développeurs qui créent des applications Web complètes.

React et Node.Js : comprendre sa ligne de base, ses avantages et ses cas d'utilisation

Une introduction à React.JS (bibliothèque JS frontale)

ReactJS est l'une des bibliothèques JavaScript frontales les plus populaires qui permet aux développeurs de créer de grandes applications Web avec des vues dynamiques basées sur les données en créant des éléments d'interface utilisateur réutilisables. De plus, il offre une réactivité et des fonctionnalités fluides sur plusieurs appareils.

Source des images

Selon Statista, React.js est l'un des frameworks Web les plus populaires et les plus largement utilisés qui permet aux développeurs de concevoir des applications Web très convaincantes et évolutives sans avoir connaissance des frameworks complexes ou des langages de programmation. Étant donné que React.js est approuvé par WhatsApp, Instagram, Netflix, Airbnb, etc.

Points forts de ReactJS

  • React est un framework JS frontal convivial pour le référencement.
  • Il est livré avec une documentation détaillée et des didacticiels qui aident les débutants à démarrer le projet.
  • Il améliore les performances de l'application car il utilise Virtual DOM.
  • Il prend en charge plusieurs composants pour la création d'applications Web et améliore le processus de développement d'applications Web dynamiques.

Fonctionnalités clés de React.js

  • Il est beaucoup plus facile d'accéder et de maintenir
  • Garantir d'excellentes performances de l'application
  • Offrez un code stable
  • Idéal pour développer une application Web frontale

Cas d'utilisation de React.js

  • Création d'applications à page unique (SPA)
  • Création d'interfaces utilisateur transparentes
  • Applications de navigation Web
  • Idéal pour créer de grands sites de médias sociaux
  • Bibliothèques dynamiques

Pour utiliser pleinement React.js dans le développement d'applications Web, il vaut la peine d' embaucher un développeur React travaillant pour la principale société de développement Web React. Tirant parti de l'expertise et de l'expérience du développement d'une application avec React, ils peuvent vous aider à créer une application Web réussie.

Une introduction à Node.JS (bibliothèque JS principale)

Node.js est créé avec le moteur JavaScript V8 de Google. C'est un langage de programmation open source qui peut s'exécuter sur plusieurs plates-formes et réduire considérablement le temps de développement. Il n'y a pas besoin de duplication lors de l'utilisation du langage et des modules JS à l'aide de Node.js.

" Selon les statistiques , sur plus de 63 000 sites Web vérifiés aux États-Unis, plus de 37 000 sites Web fonctionnent sur Node.js."

Si vous vous demandez pourquoi Node.js est largement utilisé pour le développement backend de l'application Web et pourquoi vous devriez embaucher un développeur d'application Node pour le développement de l'application ? Eh bien, avant de faire confiance à ces données, nous vous présentons ici les raisons valables et les avantages de Node.js :

Avantages de Node.Js

  • Il peut être utilisé pour les applications côté serveur et côté client.
  • Basé sur le moteur V8 JS de Chrome, Node peut améliorer les performances de votre application de 50 %.
  • Les opérations d'E/S non bloquantes sauvegardent son environnement d'exécution, ce qui permet une exécution efficace du code.
  • Node offre une meilleure évolutivité que les autres serveurs JS. Il prend en charge la mise à l'échelle verticalement et horizontalement.

Fonctionnalités de Node.Js

  • Sans blocage, asynchrone et dépendant des occurrences d'événements
  • Évolutif mais non fileté
  • Il est préférable d'accélérer le processus de développement.
  • Compatibilité avec différents appareils
  • Flux de données rapide sans mise en mémoire tampon
  • Développement de code rapide
  • Basé sur JavaScript

Cas d'utilisation de Node.Js

  • Applications Web en temps réel
  • Flux de données
  • Les SPA (Single Page Applications) complexes
  • Proxy sur le serveur

Node.js est l'une des bibliothèques JavaScript les plus puissantes qui peut vous aider à créer un backend puissant. Vous pouvez embaucher des développeurs Node.js dans une excellente société de développement Web Node.js pour utiliser les principales caractéristiques et fonctionnalités de Node.js.

Est-il possible d'utiliser Node.JS avec React pour le développement d'applications Web ?

C'est correct. Node.js facilite la création d'API RESTful back-end évolutives et rapides. D'autre part, React est une bibliothèque frontale qui produit des interfaces utilisateur interactives. Avec les deux outils, vous pouvez créer des applications Web complexes et évolutives avec peu d'effort. Par conséquent, l'utilisation de React.js avec Node.js pour le développement d'applications Web complètes est une combinaison mortelle.

Avec NPM (Node Package Manager), vous pouvez installer n'importe quel package avec l'interface de ligne de commande (CLI). De plus, Node utilise Webpack et d'autres modules pour créer un fichier unique facilement compilable à partir d'une application React.

Levez la main si vous aimez Node avec React.js !

L'utilisation de React et Node.Js est-elle une combinaison mortelle pour créer une application Web Full-Stack ?

Le développement Web en combinant l'intégration React et Node JS est plus efficace et fait gagner du temps. Il permet également aux propriétaires d'entreprise de travailler sur d'autres parties plus importantes de leur entreprise.

Examinons les raisons pour lesquelles vous pourriez vouloir utiliser le développement Web full-stack.

  • Augmente l'évolutivité du projet

Lorsqu'il s'agit de construire des projets complexes, l'évolutivité est l'une des préoccupations les plus urgentes pour les entreprises. Lorsqu'ils utilisent Node.js et React ensemble en embauchant un développeur d'applications , ils peuvent créer des applications Web interactives et volumineuses basées sur les données qui fonctionnent sur une gamme d'appareils.

  • Combo de pile MERN

La pile MERN est composée de MongoDB, Express, React et Node.js. Il n'y a pas de meilleure combinaison pour donner à un site web sa dimension unique. La pile MERN fonctionne avec Node.js et React.js, de sorte que Node et React peuvent être combinés pour le développement d'applications Web.

  • Gestion des données en temps réel dans les applications

Node.js est un bon choix si vous créez une application de données en continu ou si vous gérez des données en temps réel. Ce type d'application nécessite une connexion continue au serveur et Node.js fournit une assistance constante pour votre application.

  • Développement plus rapide

La combinaison de React avec Node peut générer un retour sur investissement élevé et vous faire économiser de l'argent et du temps, car ces technologies fournissent une plate-forme idéale pour créer des sites Web rapides, efficaces et faciles à entretenir.

  • Demandes à page unique (SPA)

Vous recherchez une application d'une seule page avec un chargement de données asynchrone ? Si tel est le cas, React with a Node back-end est la solution, car il vous permet de créer un modèle back-end léger avec des fonctions de rappel.

  • Langage unique pour le développement frontal et back-end d'applications Web

Avec l'utilisation de Node et React, les développeurs n'ont pas à apprendre divers langages complexes tels que Python ou Ruby. Ils peuvent simplement utiliser Node pour le côté serveur du développement et React pour le front-end. En plus d'économiser des ressources, de l'argent et du temps, ce recyclage réduit les déchets.

  • Utilisation excessive de JavaScript

Node with React fournit JavaScript pour le front et le back-end, ce qui offre plus de liberté et de flexibilité pour créer des sites Web et des applications Web. Les développeurs peuvent utiliser JavaScript comme langage unique pour l'ensemble du processus de développement d'applications.

En un mot : si vous décidez d'utiliser Node.js et React pour créer une application Web, vous devez embaucher des développeurs Node.js ainsi que des développeurs React. De cette façon, vous utiliserez efficacement les deux technologies, formant ainsi d'excellentes applications Web pour votre entreprise.

Comment cette combinaison de Node.JS et React.Js peut-elle bénéficier à ces entreprises ?

Pour survivre sur le marché concurrentiel d'aujourd'hui, les entreprises doivent cibler leurs clients et leur fournir une solution qui offre une excellente expérience utilisateur. Heureusement, React with Node.js fournit une plate-forme qui vous permet de créer rapidement des applications Web puissantes et de maintenir un niveau élevé de performances sur un certain nombre d'appareils.

Pour ceux qui souhaitent créer des applications Web modernes et réactives capables de gérer de grandes quantités de données, Node.js et React sont d'excellentes options. Pourquoi ne pas l'essayer?

La simplicité du modèle de conception de React permet la création de composants réutilisables, tandis que l'architecture événementielle de Node.js permet de gérer de gros volumes de trafic à un rythme plus rapide.

Dans l'ensemble, choisir la combinaison mortelle pour développer des applications Web complètes sera une décision valable pour les entreprises. Ils peuvent facilement gagner du temps et de l'argent en utilisant cette combinaison Node.js et React et être en mesure d'ajouter un avantage concurrentiel à leur entreprise.

Conclusion : Développer une puissante application Full-Stack avec React et Node.js

À la fin de ce blog, il est juste de dire que ces deux technologies peuvent bien fonctionner ensemble. Node.js est une plate-forme côté serveur qui fournit une gestion des données à une vitesse efficace et peut être utilisée pour créer des serveurs Web écrits en JavaScript.

React est un framework frontal qui aide les développeurs à créer des interfaces à partir de composants utilisant Javascript. En embauchant un développeur d'applications Web , vous pouvez combiner de manière transparente ces bibliothèques JS pour créer un site Web puissant.

Les capacités robustes de ces frameworks peuvent vous aider à créer une application sans utiliser d'autres frameworks gênants et chronophages. Donc, si l'idée vous convient enfin et que vous recherchez une équipe de développeurs experts, vous pouvez déposer une requête ci-dessous !

Source : https://javascript.plainenglish.io/why-combine-react-with-node-js-for-full-stack-web-app-development-e7c29030f67

#fullstack #react #nodejs 

Combinez React avec Node.js pour le développement d'applications Web à

Combine React Con Node.js Para El Desarrollo De Aplicaciones Web De Pi

Cuando se trata de crear una aplicación web de pila completa desde cero, puede ser difícil entender cómo organizar su código de la manera más efectiva posible. Si alguna vez ha utilizado aplicaciones web tan progresivas como Netflix o Prime Videos, entonces seguramente sabe cómo su interfaz simple está envuelta en funciones complejas y potenciada por su sólido backend.

Mientras desarrolla una aplicación web como Netflix, su base de datos debe hacer una cosa, su sistema de enrutamiento debe hacer otra y su lógica comercial debe encargarse de algún aspecto de su aplicación al mismo tiempo, pero ¿cómo se combina todo eso?

Entonces, en pocas palabras, desarrollar una aplicación web se trata de crear una hermosa interfaz que mantenga a los usuarios comprometidos con una aplicación. Y lo segundo es desarrollar un backend sólido que haga que su aplicación funcione sin problemas.

En este artículo, veremos cómo crear una aplicación web completa desde cero usando React y Node. Js: dos poderosas herramientas en JavaScript. Pero antes de comenzar a leer este blog, aquí hay algunas preguntas que se le quedan en la mente:

  • ¿Por qué React y Node.js son una opción popular para desarrollar frontend y backend?
    - React y Node.Js: comprensión de su línea de base, ventajas y casos de uso
  • ¿Podemos usar Node.Js con React para el desarrollo de aplicaciones web?
  • ¿Usar React y Node.Js es una combinación letal para crear una aplicación web completa?
  • ¿Cómo puede esta combinación de Node.JS y React.Js beneficiar a tales empresas?
  • Conclusión: desarrollo de una potente aplicación Full-Stack con React.js y Node.js

Profundicemos en los detalles de cada punto...

¿Por qué React y Node.js son una opción popular para desarrollar frontend y backend?

Conclusión: la biblioteca de JavaScript React, que normalmente se usa en el front-end, puede crear interfaces de usuario atractivas. Por el contrario, Node.js, que a menudo se usa en el servidor, puede crear aplicaciones escalables. La combinación de React y Node.js será extremadamente beneficiosa para los desarrolladores que crean aplicaciones web completas.

React y Node.Js: comprensión de su línea de base, ventajas y casos de uso

Una introducción a React.JS (Biblioteca JS front-end)

ReactJS es una de las bibliotecas de JavaScript front-end más populares que permite a los desarrolladores crear grandes aplicaciones web con vistas dinámicas basadas en datos mediante la creación de elementos de interfaz de usuario reutilizables. Además, presenta una capacidad de respuesta y funcionalidad fluidas en múltiples dispositivos.

Fuente de imagen

Según Statista, React.js es uno de los marcos web más populares pero ampliamente utilizados que permite a los desarrolladores diseñar aplicaciones web altamente convincentes y escalables sin tener conocimiento de marcos complejos o lenguajes de programación. Dado que React.js cuenta con la confianza de WhatsApp, Instagram, Netflix, Airbnb y más.

Aspectos destacados clave de ReactJS

  • React es un marco JS front-end compatible con SEO.
  • Viene con documentación detallada y tutoriales que ayudan a los principiantes a poner en marcha el proyecto.
  • Mejora el rendimiento de la aplicación ya que utiliza Virtual DOM.
  • Ofrece compatibilidad con varios componentes para crear aplicaciones web y mejora el proceso de desarrollo de aplicaciones web dinámicas.

Características clave de React.js

  • Es mucho más fácil acceder y mantener
  • Garantice un excelente rendimiento de la aplicación
  • Ofrecer un código estable
  • Ideal para desarrollar front-end de aplicaciones web

Casos de uso de React.js

  • Creación de aplicaciones de una sola página (SPA)
  • Creación de interfaces de usuario perfectas
  • aplicaciones de navegación web
  • Ideal para construir grandes sitios de redes sociales.
  • Bibliotecas dinámicas

Para hacer un uso completo de React.js en el desarrollo de aplicaciones web, vale la pena contratar a un desarrollador de React que trabaje para la empresa líder en desarrollo web de React. Aprovechando los conocimientos y la experiencia de desarrollar una aplicación con React, pueden ayudarlo a crear una aplicación web exitosa.

Una introducción a Node.JS (Biblioteca JS de back-end)

Node.js se crea con el motor JavaScript V8 de Google. Es un lenguaje de programación de código abierto que puede ejecutarse en múltiples plataformas y reducir significativamente el tiempo de desarrollo. No hay necesidad de duplicación al usar el lenguaje y los módulos JS con la ayuda de Node.js.

Según las estadísticas , de más de 63 000 sitios web revisados ​​en los EE. UU., más de 37 000 sitios web se ejecutan en Node.js”.

Si se pregunta por qué Node.js se usa ampliamente para el desarrollo de back-end de la aplicación web y por qué debería contratar a un desarrollador de aplicaciones de Node para el desarrollo de la aplicación. Bueno, antes de confiar en esta información, aquí le mostramos las razones válidas y las ventajas de Node.js:

Ventajas de Node.Js

  • Se puede utilizar tanto para aplicaciones del lado del servidor como del lado del cliente.
  • Basado en el motor V8 JS de Chrome, Node puede mejorar el rendimiento de su aplicación en un 50 %.
  • Las operaciones de E/S sin bloqueo respaldan su entorno de tiempo de ejecución, por lo que permite una ejecución eficiente del código.
  • Node proporciona una mejor escalabilidad que otros servidores JS. Admite escalado tanto vertical como horizontalmente.

Características de Node.Js

  • Sin bloqueo, asíncrono y dependiente de la ocurrencia de eventos
  • Escalable pero sin subprocesos
  • Es mejor acelerar el proceso de desarrollo.
  • Compatibilidad con diferentes dispositivos.
  • Transmisión de datos rápida sin almacenamiento en búfer
  • Desarrollo rápido de código
  • Basado en JavaScript

Casos de uso de Node.Js

  • Aplicaciones web en tiempo real
  • transmisión de datos
  • SPA (aplicaciones de una sola página) que son complejas
  • Proxies en el servidor

Node.js es una de las bibliotecas de JavaScript más potentes que puede ayudarte a crear un potente backend. Puede contratar desarrolladores de Node.js en una excelente empresa de desarrollo web de Node.js para hacer uso de las características y funcionalidades clave de Node.js.

¿Es posible usar Node.JS con React para el desarrollo de aplicaciones web?

Eso es correcto. Node.js facilita la creación de API RESTful de back-end que son escalables y rápidas. Por otro lado, React es una biblioteca frontal que produce interfaces de usuario interactivas. Con ambas herramientas, puede crear aplicaciones web complejas y escalables con poco esfuerzo. Por lo tanto, usar React.js con Node.js para el desarrollo de aplicaciones web de pila completa es una combinación mortal.

Con NPM (Node Package Manager), puede instalar cualquier paquete con la interfaz de línea de comandos (CLI). Además, Node usa Webpack y otros módulos para crear un único archivo fácilmente compilable desde una aplicación React.

¡Levanta la mano si te gusta Node con React.js!

¿Usar React y Node.Js es una combinación letal para crear una aplicación web completa?

El desarrollo web al combinar la integración de React y Node JS es más eficiente y ahorra tiempo. También permite a los dueños de negocios trabajar en otras partes más importantes de su negocio.

Veamos las razones por las que es posible que desee utilizar el desarrollo web de pila completa.

  • Aumenta la escalabilidad del proyecto

Cuando se trata de construir proyectos complejos, la escalabilidad es una de las preocupaciones más apremiantes para las empresas. Al usar Node.js y React juntos mediante la contratación de un desarrollador de aplicaciones , pueden crear aplicaciones web interactivas y de gran tamaño basadas en datos que funcionan en una variedad de dispositivos.

  • Combo de pila MERN

La pila MERN está compuesta por MongoDB, Express, React y Node.js. No hay mejor combinación para dotar a un sitio web de su dimensión única. MERN Stack funciona con Node.js y React.js, por lo que Node y React se pueden combinar para el desarrollo de aplicaciones web.

  • Gestión de datos en tiempo real en aplicaciones

Node.js es una buena opción si está creando una aplicación de transmisión de datos o manejando datos en tiempo real. Este tipo de aplicación requiere una conexión continua con el servidor y Node.js brinda soporte constante para su aplicación.

  • Desarrollo más rápido

La combinación de React con Node puede generar un alto retorno de la inversión y ahorrarle dinero y tiempo, ya que estas tecnologías brindan una plataforma ideal para crear sitios web rápidos, efectivos y fáciles de mantener.

  • Aplicaciones de una sola página (SPA)

¿Está buscando una aplicación de una sola página con carga de datos asíncrona? Si es así, React with a Node back-end es el camino a seguir, ya que le permite crear un modelo de back-end liviano con funciones de devolución de llamada.

  • Lenguaje único para el desarrollo frontal y posterior de la aplicación web

Con el uso de Node y React, los desarrolladores no tienen que aprender varios lenguajes complejos como Python o Ruby. Simplemente pueden usar Node para el lado del servidor de desarrollo y React para el front-end. Además de ahorrar recursos, dinero y tiempo, este reciclaje reduce los residuos.

  • Uso excesivo de JavaScript

Node with React provides JavaScript for both the front and back end, and this provides more freedom and flexibility to create websites and web apps. Developers can use JavaScript as a single language for the entire app development process.

In a nutshell: Should you decide to use Node.js and React to build a web application, you should hire Node.js developers as well as React developers. In this way, you will effectively use both technologies, thereby forming excellent web apps for your business.

How Can This Combination of Node.JS and React.Js Benefit Such Businesses?

Para sobrevivir en el competitivo mercado actual, las empresas deben dirigirse a sus clientes y brindarles una solución que ofrezca una excelente experiencia de usuario. Afortunadamente, React with Node.js proporciona una plataforma que le permite crear potentes aplicaciones web rápidamente y mantener un alto nivel de rendimiento en varios dispositivos.

Para aquellos que deseen crear aplicaciones web modernas y receptivas que puedan manejar grandes cantidades de datos, Node.js y React son excelentes opciones. ¿Por qué no darle una oportunidad?

La simplicidad del modelo de diseño de React permite la creación de componentes reutilizables, mientras que la arquitectura basada en eventos de Node.js permite manejar grandes volúmenes de tráfico a un ritmo más rápido.

En general, elegir la combinación mortal para desarrollar aplicaciones web completas será una decisión valiosa para las empresas. Pueden ahorrar tiempo y dinero fácilmente usando esta combinación de Node.js y React y pueden agregar una ventaja competitiva a su negocio.

Conclusión: desarrollo de una potente aplicación Full-Stack con React y Node.js

Al final de este blog, es justo decir que estas dos tecnologías pueden funcionar bien juntas. Node.js es una plataforma del lado del servidor que proporciona manejo de datos a una velocidad eficiente y puede usarse para construir servidores web escritos en JavaScript.

React es un marco front-end que ayuda a los desarrolladores a crear interfaces a partir de componentes usando Javascript. Al contratar a un desarrollador de aplicaciones web , puede combinar sin problemas estas bibliotecas JS para crear un sitio web poderoso.

Las capacidades sólidas de estos marcos pueden ayudarlo a crear una aplicación sin el uso de otros marcos problemáticos y que consumen mucho tiempo. Entonces, si finalmente le convence la idea y busca un equipo experto de desarrolladores, ¡aquí puede dejar una consulta a continuación!

Fuente: https://javascript.plainenglish.io/why-combine-react-with-node-js-for-full-stack-web-app-development-e7c29030f67

#fullstack #react #nodejs 

Combine React Con Node.js Para El Desarrollo De Aplicaciones Web De Pi

Combine React With Node.js For Full-Stack Web App Development

When it comes to building a full-stack web app from scratch, it can be hard to understand how to organize your code in the most effective way possible. If you have ever used such progressive web apps as Netflix or Prime Videos, then you surely know how their simple interface is wrapped in complex features and empowered by their strong backend.

While developing a web app like Netflix, your database should do one thing, your routing system should do another, and your business logic should take care of some aspect of your application all at once — but how does that all come together?

So, in a nutshell, developing a web app is all about creating a beautiful frontend that keeps your users engaged with an app. And the second thing is developing a strong backend that makes your app perform smoothly.

In this article, we’ll look at how to build an entire web app from scratch using React and Node. Js — two powerful tools in JavaScript. But before you begin reading this blog, here are a few questions that stick in your mind:

See more at: https://javascript.plainenglish.io/why-combine-react-with-node-js-for-full-stack-web-app-development-e7c29030f67

#fullstack #react #nodejs 

Combine React With Node.js For Full-Stack Web App Development
Hoang  Ha

Hoang Ha

1660881900

Xây Dựng ứng Dụng Ngăn Xếp Đầy Đủ Với Next.js Và Supabase

Khi nói đến việc xây dựng và lựa chọn các khuôn khổ cho ứng dụng full-stack tiếp theo của bạn, kết hợp Next.js với Supabase là một trong những lựa chọn tốt nhất để làm việc theo ý kiến ​​của tôi.

Supabase là một giải pháp thay thế Firebase mã nguồn mở với rất nhiều công cụ mạnh mẽ, bao gồm xác thực liền mạch . Là một nhà phát triển, đây là chìa khóa để xây dựng một ứng dụng full-stack thành công.

Cùng với xác thực, Supabase đi kèm với các tính năng khác, chẳng hạn như cơ sở dữ liệu Postgres, đăng ký thời gian thực và lưu trữ đối tượng. Tôi tin rằng Supabase là một trong những dịch vụ phụ trợ dễ dàng nhất để bắt đầu hoặc tích hợp.

Trong bài viết này, chúng ta sẽ tìm hiểu cách xây dựng một ứng dụng đầy đủ bằng cách sử dụng Next.js và Supabase . Chúng ta sẽ nói về cách thiết lập dự án Supabase, định cấu hình giao diện người dùng, triển khai xác thực và các chức năng.

Khái niệm của ứng dụng này là để người dùng theo dõi và tạo các hoạt động tập luyện dựa trên các thông số được chỉ định, chỉnh sửa các hoạt động này nếu có bất kỳ sai sót hoặc thay đổi cần thiết nào và xóa chúng nếu cần. Bắt đầu nào!

Giới thiệu về Next.js và Supabase

Next.js là một trong những cách dễ nhất và phổ biến nhất để xây dựng các ứng dụng React sẵn sàng sản xuất. Trong những năm gần đây, Next.js đã có sự tăng trưởng đáng kể theo cấp số nhân và nhiều công ty đã áp dụng nó để xây dựng các ứng dụng của họ.

Tại sao chúng ta nên sử dụng Supabase?

Supabase là một giải pháp thay thế mã nguồn mở, không máy chủ cho Firebase được xây dựng trên cơ sở dữ liệu PostgreSQL. Nó cung cấp tất cả các dịch vụ phụ trợ cần thiết để tạo một ứng dụng full-stack.

Với tư cách là người dùng, bạn có thể quản lý cơ sở dữ liệu của mình từ giao diện Supabase, từ việc tạo bảng và mối quan hệ để viết các truy vấn SQL và công cụ thời gian thực trên PostgreSQL.

Supabase đi kèm với các tính năng thực sự thú vị giúp việc phát triển ứng dụng toàn ngăn xếp của bạn trở nên dễ dàng hơn. Một số tính năng này là:

  • Bảo mật mức hàng (RLS) - Supabase đi kèm với tính năng PostgreSQL RLS cho phép bạn hạn chế các hàng trong bảng cơ sở dữ liệu của mình. Khi bạn tạo các chính sách, bạn tạo chúng trực tiếp bằng SQL
  • Cơ sở dữ liệu thời gian thực - Supabase có tính năng cập nhật trên cơ sở dữ liệu PostgreSQL có thể được sử dụng để lắng nghe các thay đổi trong thời gian thực
  • Supabase UI - Supabase có thư viện thành phần giao diện người dùng mã nguồn mở để tạo ứng dụng nhanh chóng và hiệu quả
  • Xác thực người dùng - Supabase tạo một auth.usersbảng ngay sau khi bạn tạo cơ sở dữ liệu của mình. Khi bạn tạo một ứng dụng, Supabase cũng sẽ chỉ định người dùng và ID ngay khi bạn đăng ký trên ứng dụng có thể được tham chiếu trong cơ sở dữ liệu. Đối với các phương pháp đăng nhập, có nhiều cách khác nhau để bạn có thể xác thực người dùng như email, mật khẩu, liên kết ma thuật, Google, GitHub, v.v.
  • Các hàm Edge - Các hàm Edge là các hàm TypeScript được phân phối toàn cầu ở rìa, gần với người dùng. Chúng có thể được sử dụng để thực hiện các chức năng như tích hợp với bên thứ ba hoặc lắng nghe WebHooks

Bắt đầu dự án của chúng tôi với Next.js

Để bắt đầu dự án của chúng tôi trong terminal với mẫu Next.js, chúng tôi sẽ chạy lệnh sau:

npx create-next-app nextjs-supabase

nextjs-supabaselà tên thư mục của ứng dụng của chúng tôi, nơi chúng tôi sẽ bao gồm mẫu ứng dụng Next.js.

Chúng tôi sẽ cần cài đặt gói ứng dụng Supabase để kết nối với ứng dụng Next.js của chúng tôi sau này. Chúng ta có thể làm như vậy bằng cách chạy một trong các lệnh sau:

yarn add @supabase/supabase-js

hoặc

npm i @supabase/supabase-js

Khi ứng dụng đã hoàn tất thiết lập, hãy mở thư mục trong trình chỉnh sửa mã yêu thích của bạn. Bây giờ, chúng tôi có thể xóa mẫu cơ bản trong /pages/index.jstệp của mình và thay thế bằng h1tiêu đề “Chào mừng bạn đến với Ứng dụng Workout”.

Sau khi hoàn tất, hãy chạy lệnh yarn devtrong terminal để khởi động ứng dụng của bạn tại http: // localhost: 3000 . Bạn sẽ thấy một trang như thế này:

Màn hình chào mừng

Thiết lập dự án Supabase và tạo bảng cơ sở dữ liệu

Để thiết lập dự án Supabase, hãy truy cập app.supabase.com để đăng nhập vào trang tổng quan ứng dụng bằng tài khoản GitHub của bạn.

Bảng điều khiển siêu dữ liệu

Sau khi đăng nhập, bạn có thể tạo tổ chức của mình và thiết lập một dự án mới trong tổ chức đó bằng cách nhấp vào Tất cả dự án .

Tất cả các dự án và màn hình tổ chức

Nhấp vào Dự án mới và đặt tên và mật khẩu cơ sở dữ liệu cho dự án của bạn. Nhấp vào nút Tạo dự án mới ; sẽ mất vài phút để dự án của bạn bắt đầu và chạy.

Tạo một dự án mới

Khi dự án đã được tạo, bạn sẽ thấy một bảng điều khiển như sau:

Workout Next Supabase Dashboard

Đối với hướng dẫn này, tôi đã tạo một dự án có tênworkout-next-supabase.

Bây giờ, hãy tạo bảng cơ sở dữ liệu của chúng ta bằng cách nhấp vào biểu tượng SQL Editor trên trang tổng quan của chúng tôi và nhấp vào Truy vấn mới . Nhập truy vấn SQL bên dưới vào trình soạn thảo và nhấp vào RUN để thực hiện truy vấn.

CREATE TABLE workouts (
 id bigint generated by default as identity primary key,
 user_id uuid references auth.users not null,
 user_email text,
 title text,
 loads text,
 reps text,
 inserted_at timestamp with time zone default timezone('utc'::text, now()) not null
);

alter table workouts enable row level security;

create policy "Individuals can create workouts." on workouts for
   insert with check (auth.uid() = user_id);

create policy "Individuals can update their own workouts." on workouts for
   update using (auth.uid() = user_id);

create policy "Individuals can delete their own workouts." on workouts for
   delete using (auth.uid() = user_id);

create policy "Workouts are public." on workouts for
   select using (true);

Thực thi truy vấn của bạn

Thao tác này sẽ tạo bảng tập luyện mà chúng tôi sẽ sử dụng để xây dựng ứng dụng CRUD của mình.

Cùng với việc tạo bảng, các quyền ở cấp độ hàng sẽ được bật để đảm bảo rằng chỉ những người dùng được ủy quyền mới có thể tạo, cập nhật hoặc xóa các chi tiết về bài tập của họ.

Để xem bảng tập luyện trông như thế nào, chúng ta có thể nhấp vào biểu tượng Trình chỉnh sửa bảng trên trang tổng quan để xem bảng tập luyện mà chúng ta vừa tạo.

Đối với ứng dụng này, chúng ta sẽ có bảy cột:

  • user_id
  • user_email
  • id
  • title
  • loads
  • reps
  • Date stamp

Trình chỉnh sửa bảng

Khi bảng và cột của chúng ta đã được thiết lập, bước tiếp theo là kết nối cơ sở dữ liệu Supabase với ứng dụng giao diện người dùng Next.js của chúng ta!

Kết nối Next.js với cơ sở dữ liệu Supabase

Để kết nối Supabase với ứng dụng Next.js của chúng tôi, chúng tôi sẽ cần URL dự ánAnon Key . Cả hai điều này có thể được tìm thấy trên bảng điều khiển cơ sở dữ liệu của chúng tôi. Để lấy hai phím này, hãy nhấp vào biểu tượng bánh răng để chuyển đến Cài đặt và sau đó nhấp vào API . Bạn sẽ thấy hai phím này hiển thị như sau:

Thiết lập url Api

Tất nhiên, chúng tôi không muốn để lộ những giá trị này một cách công khai trên trình duyệt hoặc kho lưu trữ của chúng tôi vì đó là thông tin nhạy cảm. Với lợi thế của chúng tôi, Next.js cung cấp hỗ trợ sẵn có cho các biến môi trường cho phép chúng tôi tạo một .env.localtệp trong thư mục gốc của dự án của chúng tôi. Điều này sẽ tải các biến môi trường của chúng tôi và hiển thị chúng với trình duyệt bằng cách thêm tiền tố vào NEXT_PUBLIC.

Bây giờ, hãy tạo một .env.localtệp trong thư mục gốc của dự án và bao gồm URL và khóa của chúng tôi trong tệp.

.env.local NEXT_PUBLIC_SUPABASE_URL = // dán url dự án của bạn vào đây NEXT_PUBLIC_SUPABASE_ANON_KEY = // dán khóa anon siêu dữ liệu của bạn vào đây

NB, Đừng quên đưa .env.localvào gitignoretệp của bạn để ngăn nó bị đẩy lên repo GitHub (và có sẵn cho mọi người xem) khi triển khai.

Bây giờ chúng ta hãy tạo tệp khách hàng Supabase của chúng ta bằng cách tạo một tệp được gọi supabase.jsở gốc của dự án của chúng ta. Bên trong supabase.jstệp, chúng tôi sẽ viết mã sau:

// supabase.js
import { createClient } from "@supabase/supabase-js";

const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
const supabaseKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;

export const supabase = createClient(supabaseUrl, supabaseKey);

Ở đây, chúng tôi đang nhập một createClienthàm từ Supabase và tạo một biến được gọi là supabase. Chúng tôi gọi createClienthàm và sau đó chuyển vào các tham số của chúng tôi: URL ( supabaseUrl) và Anon Key ( supabaseKey).

Bây giờ, chúng ta có thể gọi và sử dụng ứng dụng khách Supabase ở bất kỳ đâu trong dự án của mình!

Định cấu hình giao diện người dùng của ứng dụng của chúng tôi

Trước tiên, chúng ta cần định cấu hình ứng dụng của mình theo cách chúng ta muốn. Chúng tôi sẽ có một thanh điều hướng với tên dự án và các tùy chọn Đăng nhậpĐăng ký khi ứng dụng được tải lần đầu tiên. Khi người dùng đăng ký và đăng nhập, chúng tôi sẽ hiển thị thanh điều hướng để có các nút Home , LogoutCreate Workout .

Cũng sẽ có một chân trang trên mỗi trang trên trang web.

Để làm điều này, chúng tôi sẽ tạo một componentthư mục chứa Navbar.jsFooter.jscác tệp. Sau đó, bên trong _app.js, chúng tôi sẽ bọc pagesthành phần của mình bằng Navbarvà các Footerthành phần để chúng được hiển thị trên mọi trang của ứng dụng.

// _app.js
import Footer from "../components/Footer";
import Navbar from "../components/Navbar";
import "../styles/globals.css";

function MyApp({ Component, pageProps }) {
 return (
   <div>
     <Navbar/>
     <Component {...pageProps}/>
     <Footer />
   </div>
 );
}

export default MyApp;

Tôi đã tạo ý chính GitHub ở đây để xem hai thành phần này trông như thế nào cùng với các kiểu tôi đã sử dụng.

Bây giờ, trang chủ của chúng tôi sẽ trông như thế này:

Màn hình chính Adrenargy

Triển khai xác thực người dùng

Để triển khai xác thực người dùng, chúng tôi sẽ khởi tạo trạng thái người dùng trong _app.jstệp của mình và tạo một validateUserhàm để kiểm tra và xác thực người dùng. Sau đó, chúng tôi sẽ đặt trạng thái người dùng thành đối tượng phiên được trả về.

// _app.js

import { useState, useEffect } from "react";
import Footer from "../components/Footer";
import Navbar from "../components/Navbar";
import "../styles/globals.css";
import { supabase } from "../utils/supabase";

function MyApp({ Component, pageProps }) {
 const [session, setSession] = useState(null);

 useEffect(() => {
   setSession(supabase.auth.session());
   supabase.auth.onAuthStateChange((_event, session) => {
     setSession(session);
   });
 }, []);
 return (
   <div>
     <Navbar session={session} />
     <Component {...pageProps} session={session} />
     <Footer />
   </div>
 );
}
export default MyApp;

Khi người dùng tải trang chủ của ứng dụng của chúng tôi, chúng tôi muốn hiển thị một nút để yêu cầu họ đăng nhập hoặc đăng ký. Khi nhấp vào nút Đăng nhập , nút này sẽ chuyển hướng người dùng đến một trang nơi người dùng có thể nhập email và mật khẩu của họ. Nếu họ là người dùng hiện tại và chi tiết đăng nhập hợp lệ, họ sẽ được chuyển hướng đến trang chủ.

Nếu người dùng có thông tin đăng nhập không hợp lệ, một thông báo cảnh báo sẽ hiển thị để cho người dùng biết về sự cố. Thay vào đó, họ sẽ được hiển thị một tùy chọn đăng ký.

Khi người dùng đăng ký, một email xác nhận sẽ được gửi đến email họ đã nhập. họ sẽ cần xác nhận email của mình bằng cách nhấp vào liên kết trong nội dung email.

Xác nhận Email Đăng ký

Bây giờ, khi chúng tôi nhấp vào nút Đăng nhập , chúng tôi sẽ được chuyển hướng đến trang người dùng đến trang này:

Trang đăng nhập

Bây giờ, chúng ta có thể nhấp vào nút Đăng ký và nhập email.

Trang đăng ký

Khi chúng tôi nhấp vào đây, một email sẽ được gửi để xác nhận địa chỉ email. Sau khi xác nhận, nó sẽ đăng nhập cho chúng tôi và chúng tôi sẽ thấy một trang như thế này:

Màn hình chào mừng mà không cần tập luyện

Lưu ý rằng nếu chúng tôi chưa đăng nhập, chúng tôi không thể xem bảng điều khiển hoạt động của mình, thấy nút để tạo bài tập mới hoặc đăng xuất. Đây là xác thực được đề cập ban đầu được cung cấp cho chúng tôi bởi Supabase!

Thực hiện các chức năng tập luyện

Bây giờ, chúng ta sẽ đi sâu vào việc tạo khả năng tạo, sửa đổi và xóa các bài tập của người dùng.

Tìm nạp tất cả các bài tập

Chúng tôi sẽ cần tìm nạp tất cả các bài tập mà chúng tôi sẽ tạo và hiển thị chúng trên trang chủ. Chúng tôi sẽ thực hiện việc này bên trong index.jstệp:

// /pages/index.js
import Head from "next/head";
import Link from "next/link";
import { useEffect, useState } from "react";
import styles from "../styles/Home.module.css";
import { supabase } from "../utils/supabase";
import WorkoutCard from "../components/WorkoutCard";

export default function Home({ session }) {
 const [workouts, setWorkouts] = useState([]);
 const [loading, setLoading] = useState(true);

 useEffect(() => {
   fetchWorkouts();
 }, []);

 const fetchWorkouts = async () => {
   const user = supabase.auth.user();
   try {
     setLoading(true);
     const { data, error } = await supabase
       .from("workouts")
       .select("*")
       .eq("user_id", user?.id);

     if (error) throw error;
     setWorkouts(data);
   } catch (error) {
     alert(error.message);
   } finally {
     setLoading(false);
   }
 };

 if (loading) {
   return <div className={styles.loading}>Fetching Workouts...</div>;
 }
 return (
   <div className={styles.container}>
     <Head>
       <title>Nextjs x Supabase</title>
       <meta name="description" content="Generated by create next app" />
       <link rel="icon" href="/favicon.ico" />
     </Head>

     <div className={styles.home}>
       {!session?.user ? (
         <div>
           <p>
             Welcome to Adrenargy. Kindly log in to your account or sign in for
             a demo
           </p>
         </div>
       ) : (
         <div>
           <p className={styles.workoutHeading}>
             Hello <span className={styles.email}>{session.user.email}</span>,
             Welcome to your dashboard
           </p>
           {workouts?.length === 0 ? (
             <div className={styles.noWorkout}>
               <p>You have no workouts yet</p>
               <Link href="/create">
                 <button className={styles.button}>
                   {" "}
                   Create a New Workout
                 </button>
               </Link>
             </div>
           ) : (
             <div>
               <p className={styles.workoutHeading}>Here are your workouts</p>
               <WorkoutCard data={workouts}/>
             </div>
           )}
         </div>
       )}
     </div>
   </div>
 );
}

Trong thành phần này, chúng tôi đang hủy cấu sessiontrúc đối tượng mà chúng tôi đã chuyển từ các pageđạo cụ trong _app.jstệp và sử dụng đối tượng đó để xác thực người dùng được ủy quyền. Nếu không có người dùng, trang tổng quan sẽ không được hiển thị. Nếu có người dùng đăng nhập, bảng điều khiển các bài tập sẽ xuất hiện. Và nếu chưa có bài tập nào được tạo, một văn bản cho biết “Bạn chưa có bài tập nào” và nút để tạo một bài tập mới sẽ xuất hiện.

Để hiển thị các bài tập đã tạo của chúng tôi, chúng tôi có hai trạng thái:, workoutsmột mảng trống và một loadingtrạng thái nhận giá trị boolean là true. Chúng tôi đang sử dụng useEffectđể tìm nạp dữ liệu tập luyện từ cơ sở dữ liệu khi trang được tải.

Hàm fetchWorkoutsđược sử dụng để gọi cá thể Supabase để trả về tất cả dữ liệu từ các bảng tập luyện trong cơ sở dữ liệu của chúng tôi bằng selectphương pháp này. Các . eq()phương pháp lọc được sử dụng để lọc ra và chỉ trả về dữ liệu có id người dùng phù hợp với người dùng đăng nhập hiện tại. Sau đó, setWorkoutsđược đặt thành dữ liệu được gửi từ cơ sở dữ liệu và setLoadingđược đặt trở lại sau falsekhi chúng tôi tìm nạp dữ liệu của mình.

Nếu dữ liệu vẫn đang được tìm nạp, trang sẽ hiển thị “Tìm nạp các bài tập…” và nếu yêu cầu được thực hiện đến cơ sở dữ liệu của chúng tôi trả về mảng các bài tập của chúng tôi, chúng tôi muốn ánh xạ qua mảng và hiển thị WorkoutCardthành phần.

Trong WorkoutCardthành phần, chúng tôi đang hiển thị tiêu đề bài tập, tải, số lần tập và ngày giờ nó được tạo. Thời gian được tạo đang được định dạng bằng date-fnsthư viện mà bạn có thể xem tại đây . Chúng ta sẽ xem các thẻ của chúng ta trông như thế nào khi chúng ta bắt đầu tạo chúng trong phần tiếp theo.

// Workoutcard.js

import Link from "next/link";
import styles from "../styles/WorkoutCard.module.css";
import { BsTrash } from "react-icons/bs";
import { FiEdit } from "react-icons/fi";
import { formatDistanceToNow } from "date-fns/";

const WorkoutCard = ({ data }) => {
 return (
   <div className={styles.workoutContainer}>
     {data?.map((item) => (
       <div key={item.id} className={styles.container}>
         <p className={styles.title}>
           {" "}
           Title: {""}
           {item.title}
         </p>
         <p className={styles.load}>
           {" "}
           Load(kg): {"  "}
           {item.loads}
         </p>
         <p className={styles.reps}>Reps:{item.reps}</p>
         <p className={styles.time}>
           created:{" "}
           {formatDistanceToNow(new Date(item.inserted_at), {
             addSuffix: true,
           })}
         </p>
       </div>
     ))}
   </div>
 );
};

export default WorkoutCard;

Tạo một bài tập mới

Bây giờ chúng tôi đã đăng nhập, trang tổng quan của chúng tôi mới và sạch sẽ. Để triển khai khả năng tạo một bài tập mới, chúng tôi sẽ thêm create.jsCreate.module.csscác tệp trong thư mục pagesstylestương ứng, đồng thời triển khai một số logic và kiểu dáng.

// /pages/create.js

import { supabase } from "../utils/supabase";
import { useState } from "react";
import styles from "../styles/Create.module.css";
import { useRouter } from "next/router";

const Create = () => {
 const initialState = {
   title: "",
   loads: "",
   reps: "",
 };

 const router = useRouter();
 const [workoutData, setWorkoutData] = useState(initialState);

 const { title, loads, reps } = workoutData;

 const handleChange = (e) => {
   setWorkoutData({ ...workoutData, [e.target.name]: e.target.value });
 };

 const createWorkout = async () => {
   try {
     const user = supabase.auth.user();

     const { data, error } = await supabase
       .from("workouts")
       .insert([
         {
           title,
           loads,
           reps,
           user_id: user?.id,
         },
       ])
       .single();
     if (error) throw error;
     alert("Workout created successfully");
     setWorkoutData(initialState);
     router.push("/");
   } catch (error) {
     alert(error.message);
   }
 };

 return (
   <>
     <div className={styles.container}>
       <div className={styles.form}>
         <p className={styles.title}>Create a New Workout</p>
         <label className={styles.label}>Title:</label>
         <input
           type="text"
           name="title"
           value={title}
           onChange={handleChange}
           className={styles.input}
           placeholder="Enter a title"
         />
         <label className={styles.label}>Load (kg):</label>
         <input
           type="text"
           name="loads"
           value={loads}
           onChange={handleChange}
           className={styles.input}
           placeholder="Enter weight load"
         />
         <label className={styles.label}>Reps:</label>
         <input
           type="text"
           name="reps"
           value={reps}
           onChange={handleChange}
           className={styles.input}
           placeholder="Enter number of reps"
         />

         <button className={styles.button} onClick={createWorkout}>
           Create Workout
         </button>
       </div>
     </div>
   </>
 );
};

export default Create;

Ở đây, phạm vi giao diện người dùng cơ bản là chúng ta sẽ có một biểu mẫu để tạo một bài tập mới. Biểu mẫu sẽ bao gồm ba trường (tiêu đề, tải và đại diện) như chúng tôi đã chỉ định khi tạo cơ sở dữ liệu của mình.

Một đối tượng trạng thái ban đầu được định nghĩa để xử lý tất cả các trường này đã được chuyển đến workoutsDatatrạng thái. Hàm onChangeđược sử dụng để xử lý các thay đổi của trường đầu vào.

Hàm createWorkoutsử dụng cá thể máy khách Supabase để tạo một bài tập mới bằng cách sử dụng các trường trạng thái ban đầu mà chúng tôi đã xác định và chèn nó vào bảng cơ sở dữ liệu.

Cuối cùng, chúng tôi có một bánh mì nướng thông báo cho chúng tôi biết khi bài tập mới của chúng tôi đã được tạo.

Sau đó, chúng tôi đặt dữ liệu biểu mẫu trở lại trạng thái chuỗi trống ban đầu khi bài tập của chúng tôi đã được tạo. Sau đó, chúng tôi đang sử dụng router.pushphương pháp này để điều hướng người dùng quay lại trang chủ.

Tạo dự án mới

Đã tạo thành công bài tập

Bảng điều khiển với bài tập Dumbell Press

Cập nhật bài tập

Để cập nhật bài tập, chúng tôi sẽ tạo một thư mục có tên edittrong pagesthư mục chứa [id].jstệp của chúng tôi. Chúng tôi sẽ tạo một biểu tượng liên kết chỉnh sửa trên thẻ thành phần tập luyện của chúng tôi liên kết đến trang này. Khi các thẻ được hiển thị trên trang chủ, chúng ta có thể nhấp vào biểu tượng chỉnh sửa này và nó sẽ đưa chúng ta đến trang chỉnh sửa của thẻ cụ thể đó.

Sau đó, chúng tôi sẽ tìm nạp thông tin chi tiết của thẻ tập luyện cần thiết để được cập nhật từ bảng tập luyện của chúng tôi bởi idchủ sở hữu được ủy quyền và của thẻ đó. Sau đó, chúng tôi sẽ tạo một updateWorkoutchức năng để cập nhật chi tiết thẻ tập luyện của chúng tôi:

// /pages/edit/[id].js
import { useRouter } from "next/router";
import { useEffect, useState } from "react";
import styles from "../../styles/Edit.module.css";
import { supabase } from "../../utils/supabase";

const Edit = () => {
 const [workout, setWorkout] = useState("");
 const router = useRouter();

 const { id } = router.query;
 useEffect(() => {
   const user = supabase.auth.user();
   const getWorkout = async () => {
     const { data } = await supabase
       .from("workouts")
       .select("*")
       .eq("user_id", user?.id)
       .filter("id", "eq", id)
       .single();
     setWorkout(data);
   };
   getWorkout();
 }, [id]);

 const handleOnChange = (e) => {
   setWorkout({
     ...workout,
     [e.target.name]: e.target.value,
   });
 };

 const { title, loads, reps } = workout;
 const updateWorkout = async () => {
   const user = supabase.auth.user();
   const { data } = await supabase
     .from("workouts")
     .update({
       title,
       loads,
       reps,
     })
     .eq("id", id)
     .eq("user_id", user?.id);

   alert("Workout updated successfully");

   router.push("/");
 };
 return (
   <div className={styles.container}>
     <div className={styles.formContainer}>
       <h1 className={styles.title}>Edit Workout</h1>
       <label className={styles.label}> Title:</label>
       <input
         type="text"
         name="title"
         value={workout.title}
         onChange={handleOnChange}
         className={styles.updateInput}
       />
       <label className={styles.label}> Load (kg):</label>
       <input
         type="text"
         name="loads"
         value={workout.loads}
         onChange={handleOnChange}
         className={styles.updateInput}
       />
       <label className={styles.label}> Reps:</label>
       <input
         type="text"
         name="reps"
         value={workout.reps}
         onChange={handleOnChange}
         className={styles.updateInput}
       />

       <button onClick={updateWorkout} className={styles.updateButton}>
         Update Workout
       </button>
     </div>
   </div>
 );
};

export default Edit;

Đầu tiên, chúng tôi tạo một trạng thái để lưu trữ các chi tiết thẻ tập luyện sẽ được tìm nạp từ bảng của chúng tôi. Sau đó, chúng tôi trích xuất idthẻ của thẻ đó bằng cách sử dụng useRouterhook. Hàm getWorkoutgọi phiên bản máy khách Supabase để lọc idthẻ tập luyện đó và trả về dữ liệu (tiêu đề, số lần tải và số lần thực hiện).

Khi chi tiết thẻ tập luyện đã được trả lại, chúng tôi có thể tạo updateWorkoutchức năng của mình để sửa đổi các chi tiết bằng cách sử dụng .update()chức năng. Sau khi người dùng cập nhật bài tập và nhấp vào nút Cập nhật bài tập , một thông báo cảnh báo sẽ được gửi và người dùng sẽ được chuyển hướng trở lại trang chủ.

Hãy xem nó hoạt động như thế nào.

Nhấp vào biểu tượng chỉnh sửa để chuyển đến trang chỉnh sửa. Chúng tôi sẽ đổi tên tiêu đề từ “Dumbell Press” thành “Arm Curl”:

Chỉnh sửa Workout Dumbell Press

Chỉnh sửa bài tập thành công

Chỉnh sửa bài tập với máy cuộn cánh tay

Xóa bài tập

Để xóa một bài tập trên mỗi thẻ, chúng tôi sẽ tạo handleDeletehàm sẽ lấy idlàm đối số. Chúng tôi sẽ gọi phiên bản Supabase để xóa thẻ tập luyện bằng cách sử dụng

.delete()hàm số. Điều này .eq('id', id)chỉ định idhàng sẽ bị xóa trên bảng.

 const handleDelete = async (id) => {
   try {


     const user = supabase.auth.user();
     const { data, error } = await supabase
       .from("workouts")
       .delete()
       .eq("id", id)
       .eq("user_id", user?.id);
     fetchWorkouts();
     alert("Workout deleted successfully");
   } catch (error) {
     alert(error.message);
   }
 };

eq('user_id', user?.id)Được sử dụng để kiểm tra xem thẻ đang bị xóa có thuộc về người dùng cụ thể đó hay không . Hàm sẽ được chuyển đến WorkoutCardthành phần trong index.jstệp và bị hủy để sử dụng trong chính thành phần đó như sau:

const WorkoutCard = ({ data, handleDelete }) => {
 return (
   <div className={styles.workoutContainer}>
     {data?.map((item) => (
       <div key={item.id} className={styles.container}>
         <p className={styles.title}>
           {" "}
           Title: {""}
           {item.title}
         </p>
         <p className={styles.load}>
           {" "}
           Load(kg): {"  "}
           {item.loads}
         </p>
         <p className={styles.reps}>Reps:{item.reps}</p>
         <p className={styles.time}>
           created:{" "}
           {formatDistanceToNow(new Date(item.inserted_at), {
             addSuffix: true,
           })}
         </p>

         <div className={styles.buttons}>
           <Link href={`/edit/${item.id}`}>
             <a className={styles.edit}>
               <FiEdit />
             </a>
           </Link>
           <button
             onClick={() => handleDelete(item.id)}
             className={styles.delete}
           >
             <BsTrash />
           </button>
         </div>
       </div>
     ))}
   </div>
 );
};

Bánh mì nướng cảnh báo sẽ được hiển thị khi thẻ đã được xóa thành công và người dùng sẽ được chuyển hướng đến trang chủ.

Triển khai cho Vercel

Bây giờ, chúng tôi phải triển khai ứng dụng của mình cho Vercel để bất kỳ ai trên Internet đều có thể sử dụng nó!

Để triển khai Vercel, trước tiên bạn phải đẩy mã của mình vào kho lưu trữ, đăng nhập vào bảng điều khiển Vercel, nhấp vào Tạo dự án mới và nhấp vào kho lưu trữ mà bạn vừa đẩy mã của mình vào.

Nhập các biến môi trường mà chúng tôi đã tạo trước đó cùng với các giá trị của chúng ( NEXT_PUBLIC_SUPABASE_URLNEXT_PUBLIC_SUPABASE_ANON_KEY) trong trường Biến môi trường và nhấp vào Triển khai để triển khai ứng dụng của bạn vào phiên bản sản xuất.

Triển khai tới Vercel

Và chúng tôi đã có nó!

Sự kết luận

Cảm ơn bạn đã đọc! Tôi hy vọng hướng dẫn này cung cấp cho bạn kiến ​​thức bắt buộc cần thiết để tạo ứng dụng toàn ngăn xếp bằng Next.js và Supabase.

Bạn có thể tùy chỉnh kiểu cho trường hợp sử dụng của mình, vì hướng dẫn này chủ yếu tập trung vào logic của việc tạo một ứng dụng đầy đủ.

Nguồn: https://blog.logrocket.com/build-full-stack-app-next-js-supabase/

  #nextjs #supabase #fullstack 

Xây Dựng ứng Dụng Ngăn Xếp Đầy Đủ Với Next.js Và Supabase
Léon  Peltier

Léon Peltier

1660881600

Créez Une Application Complète Avec Next.js Et Supabase

Lorsqu'il s'agit de créer et de choisir des frameworks pour votre prochaine application full-stack, combiner Next.js avec Supabase est l'une des meilleures options avec lesquelles travailler à mon avis.

Supabase est une alternative open source à Firebase avec de nombreux outils puissants, y compris une authentification transparente . En tant que développeur, cela est essentiel pour créer une application complète réussie.

Outre l'authentification, Supabase est livré avec d'autres fonctionnalités, telles qu'une base de données Postgres, des abonnements en temps réel et un stockage d'objets. Je pense que Supabase est l'un des backend-as-a-services les plus faciles à démarrer ou à intégrer.

Dans cet article, nous allons apprendre à créer une application full-stack en utilisant Next.js et Supabase . Nous verrons comment configurer un projet Supabase, configurer l'interface utilisateur et implémenter l'authentification et les fonctionnalités.

Le concept de cette application est que les utilisateurs puissent suivre et créer des activités d'entraînement basées sur des paramètres spécifiés, modifier ces activités s'il y a des erreurs ou des modifications nécessaires, et les supprimer si nécessaire. Commençons!

Introduction à Next.js et Supabase

Next.js est l'un des moyens les plus simples et les plus populaires de créer des applications React prêtes pour la production. Ces dernières années, Next.js a connu une croissance exponentielle importante et de nombreuses entreprises l'ont adopté pour construire leurs applications.

Pourquoi devrions-nous utiliser Supabase ?

Supabase est une alternative open source sans serveur à Firebase construite sur la base de données PostgreSQL. Il fournit tous les services backend nécessaires pour créer une application complète.

En tant qu'utilisateur, vous pouvez gérer votre base de données à partir de l'interface Supabase, allant de la création de tables et de relations à l'écriture de vos requêtes SQL et de votre moteur en temps réel sur PostgreSQL.

Supabase est livré avec des fonctionnalités vraiment intéressantes qui facilitent encore plus le développement de votre application full-stack. Certaines de ces fonctionnalités sont :

  • Sécurité au niveau des lignes (RLS) - Supabase est livré avec la fonctionnalité PostgreSQL RLS qui vous permet de restreindre les lignes dans vos tables de base de données. Lorsque vous créez des politiques, vous les créez directement avec SQL
  • Base de données en temps réel - Supabase dispose d'une fonctionnalité de mise à jour sur la base de données PostgreSQL qui peut être utilisée pour écouter les modifications en temps réel
  • Supabase UI - Supabase dispose d'une bibliothèque de composants d'interface utilisateur open source pour créer des applications rapidement et efficacement
  • Authentification des utilisateurs – Supabase crée une auth.userstable dès que vous créez votre base de données. Lorsque vous créez une application, Supabase attribue également un utilisateur et un identifiant dès que vous vous inscrivez sur l'application qui peut être référencée dans la base de données. Pour les méthodes de connexion, il existe différentes manières d'authentifier les utilisateurs, telles que l'e-mail, le mot de passe, les liens magiques, Google, GitHub, etc.
  • Fonctions Edge – Les fonctions Edge sont des fonctions TypeScript distribuées globalement à la périphérie, à proximité des utilisateurs. Ils peuvent être utilisés pour exécuter des fonctions telles que l'intégration avec des tiers ou l'écoute de WebHooks

Initier notre projet avec Next.js

Pour lancer notre projet dans le terminal avec le template Next.js, nous allons exécuter la commande suivante :

npx create-next-app nextjs-supabase

nextjs-supabaseest le nom du dossier de notre application où nous engloberons le modèle d'application Next.js.

Nous devrons installer le package client Supabase pour nous connecter ultérieurement à notre application Next.js. Nous pouvons le faire en exécutant l'une des commandes suivantes :

yarn add @supabase/supabase-js

ou

npm i @supabase/supabase-js

Une fois l'application terminée, ouvrez le dossier dans votre éditeur de code préféré. Maintenant, nous pouvons supprimer le modèle de base de notre /pages/index.jsfichier et le remplacer par un h1titre indiquant "Bienvenue dans l'application d'entraînement".

Une fois cela fait, exécutez la commande yarn devdans le terminal pour démarrer votre application à http://localhost:3000 . Vous devriez voir une page comme celle-ci :

Ecran d'accueil

Mise en place d'un projet Supabase et création d'une table de base de données

Pour configurer un projet Supabase, visitez app.supabase.com pour vous connecter au tableau de bord de l'application à l'aide de votre compte GitHub.

Tableau de bord Supabase

Une fois connecté, vous pouvez créer votre organisation et configurer un nouveau projet au sein de celle-ci en cliquant sur Tous les projets .

Écran Tous les projets et organisation

Cliquez sur Nouveau projet et donnez à votre projet un nom et un mot de passe de base de données. Cliquez sur le bouton Créer un nouveau projet ; il faudra quelques minutes pour que votre projet soit opérationnel.

Créer un nouveau projet

Une fois le projet créé, vous devriez voir un tableau de bord comme celui-ci :

Entraînement suivant Tableau de bord Supabase

Pour ce tutoriel, j'ai déjà créé un projet nomméworkout-next-supabase.

Maintenant, créons notre table de base de données en cliquant sur l' icône de l' éditeur SQL sur notre tableau de bord et en cliquant sur Nouvelle requête . Entrez la requête SQL ci-dessous dans l'éditeur et cliquez sur RUN pour exécuter la requête.

CREATE TABLE workouts (
 id bigint generated by default as identity primary key,
 user_id uuid references auth.users not null,
 user_email text,
 title text,
 loads text,
 reps text,
 inserted_at timestamp with time zone default timezone('utc'::text, now()) not null
);

alter table workouts enable row level security;

create policy "Individuals can create workouts." on workouts for
   insert with check (auth.uid() = user_id);

create policy "Individuals can update their own workouts." on workouts for
   update using (auth.uid() = user_id);

create policy "Individuals can delete their own workouts." on workouts for
   delete using (auth.uid() = user_id);

create policy "Workouts are public." on workouts for
   select using (true);

Exécutez votre requête

Cela créera la table d'entraînement que nous utiliserons pour créer notre application CRUD.

Parallèlement à la création d'un tableau, des autorisations au niveau des lignes seront activées pour garantir que seuls les utilisateurs autorisés peuvent créer, mettre à jour ou supprimer les détails de leurs entraînements.

Pour voir à quoi ressemble le tableau d'entraînement, nous pouvons cliquer sur l' icône de l' éditeur de tableau sur le tableau de bord pour voir le tableau d'entraînement que nous venons de créer.

Pour cette application, nous aurons sept colonnes :

  • user_id
  • user_email
  • id
  • title
  • loads
  • reps
  • Date stamp

Éditeur de tableaux

Une fois notre table et nos colonnes définies, l'étape suivante consiste à connecter notre base de données Supabase à notre application frontale Next.js !

Connecter Next.js avec une base de données Supabase

Pour connecter Supabase à notre application Next.js, nous aurons besoin de notre URL de projet et de notre clé Anon . Ces deux éléments peuvent être trouvés sur notre tableau de bord de base de données. Pour obtenir ces deux clés, cliquez sur l'icône d'engrenage pour aller dans Paramètres puis cliquez sur API . Vous verrez ces deux clés apparaître comme ceci :

Configuration de l'URL de l'API

Bien sûr, nous ne voulons pas exposer ces valeurs publiquement sur le navigateur ou notre référentiel car il s'agit d'informations sensibles. À notre avantage, Next.js fournit un support intégré pour les variables d'environnement qui nous permettent de créer un .env.localfichier à la racine de notre projet. Cela chargera nos variables d'environnement et les exposera au navigateur en le préfixant avec NEXT_PUBLIC.

Maintenant, créons un .env.localfichier à la racine de notre projet et incluons notre URL et nos clés dans le fichier.

.env.local NEXT_PUBLIC_SUPABASE_URL= // collez l'url de votre projet ici NEXT_PUBLIC_SUPABASE_ANON_KEY= // collez votre clé supabase anon ici

NB, n'oubliez pas d'inclure .env.localdans votre gitignorefichier pour éviter qu'il ne soit poussé vers le référentiel GitHub (et disponible pour tout le monde) lors du déploiement.

Créons maintenant notre fichier client Supabase en créant un fichier appelé supabase.jsà la racine de notre projet. Dans le supabase.jsfichier, nous écrirons le code suivant :

// supabase.js
import { createClient } from "@supabase/supabase-js";

const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
const supabaseKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;

export const supabase = createClient(supabaseUrl, supabaseKey);

Ici, nous importons une createClientfonction de Supabase et créons une variable appelée supabase. Nous appelons la createClientfonction puis passons nos paramètres : URL ( supabaseUrl) et Anon Key ( supabaseKey).

Maintenant, nous pouvons appeler et utiliser le client Supabase n'importe où dans notre projet !

Configuration de l'interface utilisateur de notre application

Tout d'abord, nous devons configurer notre application pour qu'elle ressemble à ce que nous voulons. Nous aurons une barre de navigation avec le nom du projet et les options de connexion et d' inscription lors du premier chargement de l'application. Lorsqu'un utilisateur s'inscrit et se connecte, nous afficherons la barre de navigation avec les boutons Accueil , Déconnexion et Créer un entraînement .

Il y aura également un pied de page sur chaque page du site Web.

Pour ce faire, nous allons créer un componentdossier qui contiendra les fichiers Navbar.jset . Footer.jsEnsuite, à l'intérieur _app.jsde , nous encapsulerons notre pagescomposant avec les Navbarcomposants et Footerafin qu'ils soient affichés sur chaque page de l'application.

// _app.js
import Footer from "../components/Footer";
import Navbar from "../components/Navbar";
import "../styles/globals.css";

function MyApp({ Component, pageProps }) {
 return (
   <div>
     <Navbar/>
     <Component {...pageProps}/>
     <Footer />
   </div>
 );
}

export default MyApp;

J'ai créé un GitHub Gist ici pour voir à quoi ressemblent ces deux composants aux côtés des styles que j'ai utilisés.

Maintenant, notre page d'accueil devrait ressembler à ceci :

Écran d'accueil Adrénagie

Implémentation de l'authentification des utilisateurs

Pour implémenter l'authentification des utilisateurs, nous allons initialiser l'état de l'utilisateur dans notre _app.jsfichier et créer une validateUserfonction pour vérifier et valider un utilisateur. Nous définirons ensuite l'état de l'utilisateur sur l'objet de session renvoyé.

// _app.js

import { useState, useEffect } from "react";
import Footer from "../components/Footer";
import Navbar from "../components/Navbar";
import "../styles/globals.css";
import { supabase } from "../utils/supabase";

function MyApp({ Component, pageProps }) {
 const [session, setSession] = useState(null);

 useEffect(() => {
   setSession(supabase.auth.session());
   supabase.auth.onAuthStateChange((_event, session) => {
     setSession(session);
   });
 }, []);
 return (
   <div>
     <Navbar session={session} />
     <Component {...pageProps} session={session} />
     <Footer />
   </div>
 );
}
export default MyApp;

Lorsqu'un utilisateur charge la page d'accueil de notre application, nous voulons afficher un bouton pour lui dire de se connecter ou de s'inscrire. Lorsque le bouton de connexion est cliqué, il doit rediriger l'utilisateur vers une page où l'utilisateur peut saisir son adresse e-mail et son mot de passe. S'il s'agit d'un utilisateur existant et que les informations de connexion sont valides, il sera redirigé vers la page d'accueil.

Si l'utilisateur a des informations d'identification non valides, un message d'alerte s'affichera pour informer l'utilisateur du problème. Une option d'inscription s'affichera à la place.

Lorsque l'utilisateur s'inscrit, un e-mail de confirmation est envoyé à l'adresse e-mail saisie. ils devront confirmer leur e-mail en cliquant sur le lien dans le corps de l'e-mail.

Confirmer l'e-mail d'inscription

Maintenant, lorsque nous cliquons sur le bouton Connexion , nous devrions être redirigés vers la page utilisateur vers cette page :

Page de connexion

Maintenant, nous pouvons cliquer sur le bouton S'inscrire et entrer un e-mail.

Page d'inscription

Une fois que nous avons cliqué dessus, un e-mail sera envoyé pour confirmer l'adresse e-mail. Après confirmation, il nous connectera et nous devrions voir une page comme celle-ci :

Écran de bienvenue sans entraînement pour le moment

Notez que si nous ne nous sommes pas connectés, nous ne pouvons pas voir notre tableau de bord d'activité, voir un bouton pour créer un nouvel entraînement ou nous déconnecter. C'est l'authentification mentionnée initialement qui nous est fournie par Supabase !

Mise en œuvre des fonctionnalités d'entraînement

Maintenant, nous allons plonger dans la création de la capacité d'un utilisateur à créer, modifier et supprimer ses entraînements.

Récupération de tous les entraînements

Nous devrons récupérer tous les entraînements que nous allons créer et les afficher sur la page d'accueil. Nous allons le faire à l'intérieur du index.jsfichier :

// /pages/index.js
import Head from "next/head";
import Link from "next/link";
import { useEffect, useState } from "react";
import styles from "../styles/Home.module.css";
import { supabase } from "../utils/supabase";
import WorkoutCard from "../components/WorkoutCard";

export default function Home({ session }) {
 const [workouts, setWorkouts] = useState([]);
 const [loading, setLoading] = useState(true);

 useEffect(() => {
   fetchWorkouts();
 }, []);

 const fetchWorkouts = async () => {
   const user = supabase.auth.user();
   try {
     setLoading(true);
     const { data, error } = await supabase
       .from("workouts")
       .select("*")
       .eq("user_id", user?.id);

     if (error) throw error;
     setWorkouts(data);
   } catch (error) {
     alert(error.message);
   } finally {
     setLoading(false);
   }
 };

 if (loading) {
   return <div className={styles.loading}>Fetching Workouts...</div>;
 }
 return (
   <div className={styles.container}>
     <Head>
       <title>Nextjs x Supabase</title>
       <meta name="description" content="Generated by create next app" />
       <link rel="icon" href="/favicon.ico" />
     </Head>

     <div className={styles.home}>
       {!session?.user ? (
         <div>
           <p>
             Welcome to Adrenargy. Kindly log in to your account or sign in for
             a demo
           </p>
         </div>
       ) : (
         <div>
           <p className={styles.workoutHeading}>
             Hello <span className={styles.email}>{session.user.email}</span>,
             Welcome to your dashboard
           </p>
           {workouts?.length === 0 ? (
             <div className={styles.noWorkout}>
               <p>You have no workouts yet</p>
               <Link href="/create">
                 <button className={styles.button}>
                   {" "}
                   Create a New Workout
                 </button>
               </Link>
             </div>
           ) : (
             <div>
               <p className={styles.workoutHeading}>Here are your workouts</p>
               <WorkoutCard data={workouts}/>
             </div>
           )}
         </div>
       )}
     </div>
   </div>
 );
}

Dans ce composant, nous détruisons l' sessionobjet que nous avons transmis à partir des pageaccessoires du _app.jsfichier et l'utilisons pour valider les utilisateurs autorisés. S'il n'y a pas d'utilisateurs, le tableau de bord ne s'affichera pas. Si un utilisateur est connecté, le tableau de bord des entraînements apparaîtra. Et s'il n'y a pas d'entraînement créé, un texte disant "Vous n'avez pas encore d'entraînement" et un bouton pour en créer un nouveau apparaîtront.

Pour rendre nos entraînements créés, nous avons deux états : workouts, un tableau vide et un loadingétat qui prend une valeur booléenne de true. Nous utilisons useEffectpour récupérer les données d'entraînement de la base de données lorsque la page est chargée.

La fetchWorkoutsfonction est utilisée pour appeler l'instance Supabase pour renvoyer toutes les données des tables d'entraînement dans notre base de données à l'aide de la selectméthode. La . eq()La méthode filter est utilisée pour filtrer et renvoyer uniquement les données dont l'ID utilisateur correspond à l'utilisateur actuellement connecté. Ensuite, setWorkoutsest défini sur les données envoyées à partir de la base de données et setLoadingest rétabli falseune fois que nous avons récupéré nos données.

Si les données sont toujours en cours de récupération, la page doit afficher "Fetching Workouts…" et si la demande faite à notre base de données renvoie le tableau de nos entraînements, nous voulons mapper le tableau et rendre le WorkoutCardcomposant.

Dans le WorkoutCardcomposant, nous rendons le titre de l'entraînement, la charge, les répétitions, ainsi que la date et l'heure de sa création. L'heure créée est formatée à l'aide de la date-fnsbibliothèque que vous pouvez consulter ici . Nous verrons à quoi ressemblent nos cartes lorsque nous commencerons à les créer dans la section suivante.

// Workoutcard.js

import Link from "next/link";
import styles from "../styles/WorkoutCard.module.css";
import { BsTrash } from "react-icons/bs";
import { FiEdit } from "react-icons/fi";
import { formatDistanceToNow } from "date-fns/";

const WorkoutCard = ({ data }) => {
 return (
   <div className={styles.workoutContainer}>
     {data?.map((item) => (
       <div key={item.id} className={styles.container}>
         <p className={styles.title}>
           {" "}
           Title: {""}
           {item.title}
         </p>
         <p className={styles.load}>
           {" "}
           Load(kg): {"  "}
           {item.loads}
         </p>
         <p className={styles.reps}>Reps:{item.reps}</p>
         <p className={styles.time}>
           created:{" "}
           {formatDistanceToNow(new Date(item.inserted_at), {
             addSuffix: true,
           })}
         </p>
       </div>
     ))}
   </div>
 );
};

export default WorkoutCard;

Création d'un nouvel entraînement

Maintenant que nous sommes connectés, notre tableau de bord est frais et propre. Pour implémenter la possibilité de créer un nouvel entraînement, nous ajouterons des fichiers create.jset dans le dossier et respectivement, et implémenterons une logique et un style.Create.module.csspagesstyles

// /pages/create.js

import { supabase } from "../utils/supabase";
import { useState } from "react";
import styles from "../styles/Create.module.css";
import { useRouter } from "next/router";

const Create = () => {
 const initialState = {
   title: "",
   loads: "",
   reps: "",
 };

 const router = useRouter();
 const [workoutData, setWorkoutData] = useState(initialState);

 const { title, loads, reps } = workoutData;

 const handleChange = (e) => {
   setWorkoutData({ ...workoutData, [e.target.name]: e.target.value });
 };

 const createWorkout = async () => {
   try {
     const user = supabase.auth.user();

     const { data, error } = await supabase
       .from("workouts")
       .insert([
         {
           title,
           loads,
           reps,
           user_id: user?.id,
         },
       ])
       .single();
     if (error) throw error;
     alert("Workout created successfully");
     setWorkoutData(initialState);
     router.push("/");
   } catch (error) {
     alert(error.message);
   }
 };

 return (
   <>
     <div className={styles.container}>
       <div className={styles.form}>
         <p className={styles.title}>Create a New Workout</p>
         <label className={styles.label}>Title:</label>
         <input
           type="text"
           name="title"
           value={title}
           onChange={handleChange}
           className={styles.input}
           placeholder="Enter a title"
         />
         <label className={styles.label}>Load (kg):</label>
         <input
           type="text"
           name="loads"
           value={loads}
           onChange={handleChange}
           className={styles.input}
           placeholder="Enter weight load"
         />
         <label className={styles.label}>Reps:</label>
         <input
           type="text"
           name="reps"
           value={reps}
           onChange={handleChange}
           className={styles.input}
           placeholder="Enter number of reps"
         />

         <button className={styles.button} onClick={createWorkout}>
           Create Workout
         </button>
       </div>
     </div>
   </>
 );
};

export default Create;

Ici, la portée de base de l'interface utilisateur est que nous aurons un formulaire pour créer un nouvel entraînement. Le formulaire sera composé de trois champs (titre, charge et reps) comme nous l'avons spécifié lors de la création de notre base de données.

Un objet d'état initial est défini pour gérer tous ces champs qui ont été passés à l' workoutsDataétat. La onChangefonction est utilisée pour gérer les modifications du champ de saisie.

La createWorkoutfonction utilise l'instance du client Supabase pour créer un nouvel entraînement à l'aide des champs d'état initiaux que nous avons définis et l'insère dans la table de la base de données.

Enfin, nous avons un toast d'alerte qui nous informe lorsque notre nouvel entraînement a été créé.

Ensuite, nous remettons les données du formulaire à l'état initial de la chaîne vide une fois que notre entraînement a été créé. Après cela, nous utilisons la router.pushméthode pour ramener l'utilisateur à la page d'accueil.

Créer un nouveau projet

Entraînement créé avec succès

Tableau de bord avec entraînements Dumbell Press

Mettre à jour un entraînement

Pour mettre à jour un entraînement, nous allons créer un dossier appelé editdans notre pagesdossier qui contiendra notre [id].jsfichier. Nous allons créer une icône de lien de modification sur notre fiche de composant d'entraînement qui renvoie à cette page. Lorsque les cartes sont rendues sur la page d'accueil, nous pouvons cliquer sur cette icône d'édition et cela nous amènera à la page d'édition de cette carte particulière.

Nous allons ensuite récupérer les détails de la carte d'entraînement nécessaire à mettre à jour à partir de notre table d'entraînement par son idpropriétaire et le propriétaire autorisé de la carte. Ensuite, nous allons créer une updateWorkoutfonction pour mettre à jour les détails de notre carte d'entraînement :

// /pages/edit/[id].js
import { useRouter } from "next/router";
import { useEffect, useState } from "react";
import styles from "../../styles/Edit.module.css";
import { supabase } from "../../utils/supabase";

const Edit = () => {
 const [workout, setWorkout] = useState("");
 const router = useRouter();

 const { id } = router.query;
 useEffect(() => {
   const user = supabase.auth.user();
   const getWorkout = async () => {
     const { data } = await supabase
       .from("workouts")
       .select("*")
       .eq("user_id", user?.id)
       .filter("id", "eq", id)
       .single();
     setWorkout(data);
   };
   getWorkout();
 }, [id]);

 const handleOnChange = (e) => {
   setWorkout({
     ...workout,
     [e.target.name]: e.target.value,
   });
 };

 const { title, loads, reps } = workout;
 const updateWorkout = async () => {
   const user = supabase.auth.user();
   const { data } = await supabase
     .from("workouts")
     .update({
       title,
       loads,
       reps,
     })
     .eq("id", id)
     .eq("user_id", user?.id);

   alert("Workout updated successfully");

   router.push("/");
 };
 return (
   <div className={styles.container}>
     <div className={styles.formContainer}>
       <h1 className={styles.title}>Edit Workout</h1>
       <label className={styles.label}> Title:</label>
       <input
         type="text"
         name="title"
         value={workout.title}
         onChange={handleOnChange}
         className={styles.updateInput}
       />
       <label className={styles.label}> Load (kg):</label>
       <input
         type="text"
         name="loads"
         value={workout.loads}
         onChange={handleOnChange}
         className={styles.updateInput}
       />
       <label className={styles.label}> Reps:</label>
       <input
         type="text"
         name="reps"
         value={workout.reps}
         onChange={handleOnChange}
         className={styles.updateInput}
       />

       <button onClick={updateWorkout} className={styles.updateButton}>
         Update Workout
       </button>
     </div>
   </div>
 );
};

export default Edit;

Tout d'abord, nous créons un état pour stocker les détails de la carte d'entraînement qui seront extraits de notre table. Ensuite, on extrait le idde cette carte à l'aide du useRoutercrochet. La getWorkoutfonction appelle l'instance du client Supabase pour filtrer la idcarte d'entraînement et renvoie les données (titre, charges et répétitions).

Une fois les détails de la carte d'entraînement renvoyés, nous pouvons créer notre updateWorkoutfonction pour modifier les détails à l'aide de la .update()fonction. Une fois que l'entraînement a été mis à jour par l'utilisateur et que le bouton Mettre à jour l'entraînement est cliqué, un message d'alerte est envoyé et l'utilisateur sera redirigé vers la page d'accueil.

Voyons voir comment ça fonctionne.

Cliquez sur l'icône d'édition pour accéder à la page d'édition. Nous allons renommer le titre de "Dumbell Press" en "Arm Curl":

Modifier la presse d'haltères d'entraînement

Modifier l'entraînement réussi

Modifier l'entraînement avec la boucle des bras

Suppression d'un entraînement

Pour supprimer un entraînement sur chaque carte, nous allons créer la handleDeletefonction qui prendra le iden argument. Nous appellerons l'instance Supabase pour supprimer une carte d'entraînement à l'aide de la

.delete()fonction. Ceci .eq('id', id)spécifie la idligne à supprimer sur la table.

 const handleDelete = async (id) => {
   try {


     const user = supabase.auth.user();
     const { data, error } = await supabase
       .from("workouts")
       .delete()
       .eq("id", id)
       .eq("user_id", user?.id);
     fetchWorkouts();
     alert("Workout deleted successfully");
   } catch (error) {
     alert(error.message);
   }
 };

Le eq('user_id', user?.id)est utilisé pour vérifier si la carte qui est supprimée appartient à cet utilisateur particulier. La fonction sera transmise au WorkoutCardcomposant dans le index.jsfichier et déstructurée pour être utilisée dans le composant lui-même comme suit :

const WorkoutCard = ({ data, handleDelete }) => {
 return (
   <div className={styles.workoutContainer}>
     {data?.map((item) => (
       <div key={item.id} className={styles.container}>
         <p className={styles.title}>
           {" "}
           Title: {""}
           {item.title}
         </p>
         <p className={styles.load}>
           {" "}
           Load(kg): {"  "}
           {item.loads}
         </p>
         <p className={styles.reps}>Reps:{item.reps}</p>
         <p className={styles.time}>
           created:{" "}
           {formatDistanceToNow(new Date(item.inserted_at), {
             addSuffix: true,
           })}
         </p>

         <div className={styles.buttons}>
           <Link href={`/edit/${item.id}`}>
             <a className={styles.edit}>
               <FiEdit />
             </a>
           </Link>
           <button
             onClick={() => handleDelete(item.id)}
             className={styles.delete}
           >
             <BsTrash />
           </button>
         </div>
       </div>
     ))}
   </div>
 );
};

Un toast d'alerte s'affichera une fois la carte supprimée avec succès et l'utilisateur sera redirigé vers la page d'accueil.

Déploiement à Vercel

Maintenant, nous devons déployer notre application sur Vercel pour que n'importe qui sur Internet puisse l'utiliser !

Pour déployer sur Vercel, vous devez d'abord pousser votre code vers votre référentiel, vous connecter à votre tableau de bord Vercel, cliquer sur Créer un nouveau projet et cliquer sur le référentiel dans lequel vous venez de pousser votre code.

Entrez les variables d'environnement que nous avons créées précédemment avec leurs valeurs ( NEXT_PUBLIC_SUPABASE_URLet NEXT_PUBLIC_SUPABASE_ANON_KEY) dans le champ Variable d'environnement et cliquez sur Déployer pour déployer votre application en production.

Déployer à Vercel

Et là, nous l'avons!

Conclusion

Merci pour la lecture! J'espère que ce tutoriel vous donnera les connaissances nécessaires pour créer une application full-stack en utilisant Next.js et Supabase.

Vous pouvez personnaliser le style en fonction de votre cas d'utilisation, car ce didacticiel se concentre principalement sur la logique de création d'une application complète.

Source : https://blog.logrocket.com/build-full-stack-app-next-js-supabase/

  #nextjs #supabase #fullstack 

Créez Une Application Complète Avec Next.js Et Supabase