DEV Community: dbarun

Brute Force way of Looping Combination

dbarun — Tue, 21 May 2024 08:18:26 +0000

How Do We LOOP C(r, n) Lets loop C(3,6)
In Combination we don't care about order so the formula of combination [n!/r!(n-r)!] gives C(3, 6) value of = 6!/3!x3! = 20

We already know we need to loop 3 times as we selected 3 items but Sometimes I confused what will the array bound and It turns out to be very simple to know the array bound

Let's take an array of [1, 2, 3, 4, 5, 6]
Here r = 3 and n = 6 = len(arr)

for the first loop the array bound will be like this
I will use go/golang and the classic for loop to write
for i := 0; i <= len(arr) - 3; i++{}
or
for i := 0; i < len(arr) - 2; i++{}
the boundary should be <= len(arr) - r or < len(arr) - (r-1)

and the second will be
for j := i+1; j <= len(arr) - 2; i++{}
or
for i := i+1; j < len(arr) - 1; i++{}
the boundary should be <= len(arr) - r-1 or < len(arr) - (r-2)

I guess now you can figure out the sequence or the formula for this.

[the second variation]

SRR React With Go and Templ

dbarun — Fri, 01 Mar 2024 23:06:28 +0000

for more ref https://github.com/BarunW/form_backend/tree/main/integration-react

So I am here to share the process and It's already on the templ documentation https://templ.guide/media/, but i have some issue on that I change here and there.

Install temp go install github.com/a-h/templ/cmd/templ@latest
add go get github.com/a-h/templ to your project
now make a dir/folder inside your go project e.g react-integration
cd react-integration and make two dir/folder static(where your templ and templ geneated go file should be) and another one react()
inside static create a page.tmpl

make sure you have data to pass if you need the data to render,

package static
   import(
      "github.com/username/myrepo/types"
  )
   */
script renderIndex(bp types.BillingPlan) {
    // Use the renderIndex function from the Reactbundle
    bundle.renderIndex()
}

templ Index(bp types.BillingPlan) {
    <div id="index"></div>  
    // in templ you this to call a templ component or script  
    @renderIndex(bp)
}


templ Page(bp types.BillingPlan) {
`<html>
    <head>
        <title>React integration</title>
            <link rel="stylesheet" href="static/index.css" 
            </link>
    </head>
    <body>
        <div id="react-header"></div>
        <div id="react-content"></div>
        <div>
        </div>  
           // this index.js will be generate by es build 
        <script src="static/index.js"</script>
            @Index(c, fs) 
    </body>
</html>`
}

After this run command** templ generate** so that it will generate the required go code( make sure inside static dir/folder)

inside react do npm init -y make this files tsconfig.json and install necessary package(ts, esbuild, react, react-dom) or copy pasta this { "name": "react-integration", "version": "1.0.0", "description": "", "main": "index.ts", "author": "", "license": "ISC", "dependencies": { "react": "^18.2.0", "react-dom": "^18.2.0" }, "devDependencies": { "@types/react-dom": "^18.2.18", "esbuild": "0.20.1", "npm-run-all": "^4.1.5", "typescript": "^5.3.3" } }

we are using tsx for bundle so we use react for jsx

{
  "compilerOptions": {
      "jsx": "react", 
      "lib": ["ESNext", "DOM"],
      "esModuleInterop": true,
  }
}

create your required files for me i will create components.tsx , index.tsx and app.tsx

components.tsx
`import React from "react";

export function Component(props:any){
    return(
    <div>
       <h3 onClick={()=> console.log(data)>Click Me</h3>
    </div>
    )
}`

app.tsx

import  React, { useEffect, useRef, useState } from 'react';
import { Component } from "./components"

const App = (props : any) =>{
// do whatever you want
 return(
   <Component billingPlan={props}/>
 )
}
export default App

index.tsx

import ReactDOM from 'react-dom/client';
import React from 'react';
import App from './app';

export function renderIndex(content:any){
    const root = ReactDOM.createRoot(document.getElementById('index') as HTMLElement);
    root.render(
       <App content={content} />
    );
}

generate the index.js bundle using this command ./node_modules/.bin/esbuild --bundle index.tsx --outdir=../static --minify --global-name=bundle

Now we have to serve I like to use echo framework

package main

import(
    "github.com/labstack/echo/v4"
    "github.com/username/types"
    "net/http"

)

func main(){

  e := echo.New() 

  // middleware for serving static file
  e.Static("/static", "./integration-react/static")

  // routes 
  e.Any("/shit",echo.HandlerFunc(func(c echo.Context) error {
   // call the template component in the static
   templComp := static.Page(types.BillingPlan{})
   Render(c, http.StatusOK, templComp) 
  }))

  s := http.Server{
       Addr:        ":8080",
       Handler:     e,
   }
  if err := s.ListenAndServe(); err != http.ErrServerClosed {
    log.Fatal(err)
  }

}

// this is the echo integration with templ code
func Render(ctx echo.Context, statusCode int, tc templ.Component) error {

    ctx.Response().Writer.WriteHeader(statusCode)
    ctx.Response().Header().Set(echo.HeaderContentType, 
                                     echo.MIMETextHTML)
    return tc.Render(ctx.Request().Context(), 
                             ctx.Response().Writer)

}

Go http handlers

dbarun — Tue, 29 Aug 2023 01:01:11 +0000

A short walk on how to setup a go server using HTTP package provided by itself. Before jumping to framework I recommend you to explore and understand the packages provided by the particular programming language.

Before jumping directly to the code we need to know how go
structure the HTTP package so we need to jump to another code
i.e server.go
[](https://cs.opensource.google/go/go/+/refs/tags/go1.21.0:src/net/http/server.go)

I extract the code from the above link in case if you are too lazy to have another tab

serveMux which type is struct

type ServeMux struct {
    mu    sync.RWMutex
    m     map[string]muxEntry
    es    []muxEntry // slice of entries sorted from longest to shortest.
    hosts bool       // whether any patterns contain hostnames
}

type muxEntry struct {
    h       Handler
    pattern string
}

// NewServeMux allocates and returns a new ServeMux.
func NewServeMux() *ServeMux { return new(ServeMux) }

// DefaultServeMux is the default ServeMux used by Serve.
var DefaultServeMux = &defaultServeMux

var defaultServeMux ServeMux

Handler type Handler interface { ServeHTTP(http.ResponseWriter, *http.Request) signature }

3.Handle i.e func (mux *ServeMux) Handle(path string, handler Handler)

// Handle registers the handler for the given pattern.
// If a handler already exists for pattern, Handle panics.
func (mux *ServeMux) Handle(pattern string, handler Handler) {
    mux.mu.Lock()
    defer mux.mu.Unlock()

    if pattern == "" {
        panic("http: invalid pattern")
    }
    if handler == nil {
        panic("http: nil handler")
    }
    if _, exist := mux.m[pattern]; exist {
        panic("http: multiple registrations for " + pattern)
    }

    if mux.m == nil {
        mux.m = make(map[string]muxEntry)
    }
    e := muxEntry{h: handler, pattern: pattern}
    mux.m[pattern] = e
    if pattern[len(pattern)-1] == '/' {
        mux.es = appendSorted(mux.es, e)
    }

    if pattern[0] != '/' {
        mux.hosts = true
    }
}

4.HandleFunc

func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    if handler == nil {
        panic("http: nil handler")
    }
    mux.Handle(pattern, HandlerFunc(handler))
}

// Handle registers the handler for the given pattern
// in the DefaultServeMux.
// The documentation for ServeMux explains how patterns are matched.
func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }

// HandleFunc registers the handler function for the given pattern
// in the DefaultServeMux.
// The documentation for ServeMux explains how patterns are matched.
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    DefaultServeMux.HandleFunc(pattern, handler)
}

lets write the code to set up the server

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"
    "os/signal"
    "time"
)

type foo struct {
  l *log.Logger
}

// we can create a constructor function
func newFoo(l *log.Logger) *foo{
   return &(l)
}

/* we need to implement a ServeHTTP function in order to use  http.Handle because it takes handler as argument.Handler is an interface which has ServeHTTP signature ref 2*/

func (f *foo) ServeHTTP(rw http.ResponseWriter, r*http.Request){
   // handle all sort of things
   rw.Write([]byte("Hello"))
   return
}


func main() {

    l := log.New(os.Stdout, "go", log.LstdFlags)
    nf := newFoo(l)

    /* we can create a new serveMux if not in listenAndServe, 
    default sever is use  */
     sm := http.NewServeMux()

// routing using Handle
     sm.Handle("/",nf) 

//routing using HandleFunc 
     sm.HandleFunc("/hf",func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("handle by Handle Func"))
        return
    })

    // this server configuartion
    s := &http.Server{
        Addr: ":3000",
        Handler: sm,
        IdleTimeout : 120*time.Second,
        ReadTimeout: 1 * time.Second,
        WriteTimeout: 1*time.Second,
    }

    // we use go routine in order to independently execute 
    // and separate from main go routine
    go func() {

        err := s.ListenAndServe()
        if err != nil {
            l.Fatal(err)
        }
    }()

    /* in order to shutdown the server properly means if we want to shutdown the server it make the existing request respond properly*/
    sigChan := make(chan os.Signal) 
    signal.Notify(sigChan, os.Interrupt)
    signal.Notify(sigChan,os.Kill)

    sig := <- sigChan //this line blocks the waits for signal
    fmt.Println("gracefully shutting down server", sig)
    tc, f :=context.WithTimeout(context.Background(), 30*time.Second)
    f()
    s.Shutdown(tc)

}

---

That's all :)