v0.55.8

Try our Chrome extension

Chrome store icon Chrome Webstore

Easily add the current web-page from your browser directly into your changedetection.io tool, more great features coming soon!

Changedetection.io needs your support!

You can help us by supporting changedetection.io on these platforms;

The more popular changedetection.io is, the more time we can dedicate to adding amazing features!

Many thanks :)

changedetection.io team

  • Cannot set language without session cookie

Клавіатура: ← Попереднє   → Наступне
Ще ні секунд тому
            False
        
Ще ні секунд тому
Поточний скріншот з помилкою з останнього запиту

Тригерний текст Ігнорований текст Блокуючий текст

3 години тому
    Skip to content

      Navigation Menu

            Sign in Appearance settings
                * Platform
                        + AI CODE CREATION
                            o GitHub Copilot Write better code with AI
                            o GitHub Copilot app Direct agents from issue to merge
                            o MCP Registry Integrate external tools
                        + DEVELOPER WORKFLOWS
                            o Actions Automate any workflow
                            o Codespaces Instant dev environments
                            o Issues Plan and track work
                            o Code Review Manage code changes
                            o Code Quality Enforce quality at merge
                        + APPLICATION SECURITY
                            o GitHub Advanced Security Find and fix vulnerabilities
                            o Code security Secure your code as you build
                            o Secret protection Stop leaks before they start
                        + EXPLORE
                            o Why GitHub
                            o Documentation
                            o Blog
                            o Changelog
                            o Marketplace
                      View all features
                * Solutions
                        + BY COMPANY SIZE
                            o Enterprises
                            o Small and medium teams
                            o Startups
                            o Nonprofits
                        + BY USE CASE
                            o App Modernization
                            o DevSecOps
                            o DevOps
                            o CI/CD
                            o View all use cases
                        + BY INDUSTRY
                            o Healthcare
                            o Financial services
                            o Manufacturing
                            o Government
                            o View all industries
                      View all solutions
                * Resources
                        + EXPLORE BY TOPIC
                            o AI
                            o Software Development
                            o DevOps
                            o Security
                            o View all topics
                        + EXPLORE BY TYPE
                            o Customer stories
                            o Events & webinars
                            o Ebooks & reports
                            o Business insights
                            o GitHub Skills
                        + SUPPORT & SERVICES
                            o Documentation
                            o Customer support
                            o Community forum
                            o Trust center
                            o Partners
                      View all resources
                * Open Source
                        + COMMUNITY
                            o GitHub Sponsors Fund open source developers
                        + PROGRAMS
                            o Security Lab
                            o Maintainer Community
                            o Accelerator
                            o GitHub Stars
                            o Archive Program
                        + REPOSITORIES
                            o Topics
                            o Trending
                            o Collections
                * Enterprise
                        + ENTERPRISE SOLUTIONS
                            o Enterprise platform AI-powered developer platform
                        + AVAILABLE ADD-ONS
                            o GitHub Advanced Security Enterprise-grade security features
                            o Copilot for Business Enterprise-grade AI features
                            o Premium Support Enterprise-grade 24/7 support
              * Pricing
                Type / to search
                Sign in
              Sign up Appearance settings
      You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session. Dismiss alert

              Uh oh!

              There was an error while loading. Please reload this page.

              gin-gonic / gin Public
              * Notifications You must be signed in to change notification settings
              * Fork 8.7k
                * Star 89.1k
          * Code
          * Issues 604
          * Pull requests 155
          * Discussions
          * Actions
          * Security and quality 0
          * Insights
          Additional navigation options
                  * Code
                  * Issues
                  * Pull requests
                  * Discussions
                  * Actions
                  * Security and quality
                  * Insights
                                              master
                                          Branches Tags
                                            Go to file
                                        Code
                                          Open more actions menu

                                        Folders and files

                                          Name                             Name                               Last commit message    Last commit date
                                            Latest commit                
                                                                         
                                                History                  
                                                                         
                                                2,004 Commits            
                                                  2,004 Commits          
                                                  .github                          .github                                                           
                                                  binding                          binding                                                           
                                                  codec/ json                      codec/ json                                                       
                                                  docs                             docs                                                              
                                                  examples                         examples                                                          
                                                  ginS                             ginS                                                              
                                                  internal                         internal                                                          
                                                  render                           render                                                            
                                                  testdata                         testdata                                                          
                                                  .gitignore                       .gitignore                                                        
                                                  .golangci.yml                    .golangci.yml                                                     
                                                  .goreleaser.yaml                 .goreleaser.yaml                                                  
                                                  BENCHMARKS.md                    BENCHMARKS.md                                                     
                                                  CHANGELOG.md                     CHANGELOG.md                                                      
                                                  CODE_OF_CONDUCT.md               CODE_OF_CONDUCT.md                                                
                                                  CONTRIBUTING.md                  CONTRIBUTING.md                                                   
                                                  LICENSE                          LICENSE                                                           
                                                  Makefile                         Makefile                                                          
                                                  README.md                        README.md                                                         
                                                  auth.go                          auth.go                                                           
                                                  auth_test.go                     auth_test.go                                                      
                                                  benchmarks_test.go               benchmarks_test.go                                                
                                                  codecov.yml                      codecov.yml                                                       
                                                  context.go                       context.go                                                        
                                                  context_appengine.go             context_appengine.go                                              
                                                  context_file_test.go             context_file_test.go                                              
                                                  context_test.go                  context_test.go                                                   
                                                  debug.go                         debug.go                                                          
                                                  debug_test.go                    debug_test.go                                                     
                                                  deprecated.go                    deprecated.go                                                     
                                                  deprecated_test.go               deprecated_test.go                                                
                                                  doc.go                           doc.go                                                            
                                                  errors.go                        errors.go                                                         
                                                  errors_test.go                   errors_test.go                                                    
                                                  fs.go                            fs.go                                                             
                                                  fs_test.go                       fs_test.go                                                        
                                                  gin.go                           gin.go                                                            
                                                  gin_integration_test.go          gin_integration_test.go                                           
                                                  gin_test.go                      gin_test.go                                                       
                                                  githubapi_test.go                githubapi_test.go                                                 
                                                  go.mod                           go.mod                                                            
                                                  go.sum                           go.sum                                                            
                                                  logger.go                        logger.go                                                         
                                                  logger_test.go                   logger_test.go                                                    
                                                  middleware_test.go               middleware_test.go                                                
                                                  mode.go                          mode.go                                                           
                                                  mode_test.go                     mode_test.go                                                      
                                                  path.go                          path.go                                                           
                                                  path_test.go                     path_test.go                                                      
                                                  recovery.go                      recovery.go                                                       
                                                  recovery_test.go                 recovery_test.go                                                  
                                                  response_writer.go               response_writer.go                                                
                                                  response_writer_test.go          response_writer_test.go                                           
                                                  routergroup.go                   routergroup.go                                                    
                                                  routergroup_test.go              routergroup_test.go                                               
                                                  routes_test.go                   routes_test.go                                                    
                                                  test_helpers.go                  test_helpers.go                                                   
                                                  tree.go                          tree.go                                                           
                                                  tree_test.go                     tree_test.go                                                      
                                                  utils.go                         utils.go                                                          
                                                  utils_test.go                    utils_test.go                                                     
                                                  version.go                       version.go                                                        
                                            View all files               
                                          

                                              Repository files navigation

                                                * 
                                                * README
                                                * Code of conduct
                                                * Contributing
                                                * MIT license
                                                More items

                                                Gin Web Framework

                                                📰 Gin 1.12.0 is now available!

                                              We're excited to announce the release of Gin 1.12.0! This release brings new features, performance improvements, and important bug fixes. Check out the release announcement on our official blog for the full details.

                                              Gin is a high-performance HTTP web framework written in Go. It provides a Martini-like API but with significantly better performance—up to 40 times faster—thanks to httprouter. Gin is designed for building REST APIs, web applications, and microservices where speed and developer productivity are essential.

                                              Why choose Gin?

                                              Gin combines the simplicity of Express.js-style routing with Go's performance characteristics, making it ideal for:

                                                * Building high-throughput REST APIs
                                                * Developing microservices that need to handle many concurrent requests
                                                * Creating web applications that require fast response times
                                                * Prototyping web services quickly with minimal boilerplate

                                              Gin's key features:

                                                * Zero allocation router - Extremely memory-efficient routing with no heap allocations
                                                * High performance - Benchmarks show superior speed compared to other Go web frameworks
                                                * Middleware support - Extensible middleware system for authentication, logging, CORS, etc.
                                                * Crash-free - Built-in recovery middleware prevents panics from crashing your server
                                                * JSON validation - Automatic request/response JSON binding and validation
                                                * Route grouping - Organize related routes and apply common middleware
                                                * Error management - Centralized error handling and logging
                                                * Built-in rendering - Support for JSON, XML, HTML templates, and more
                                                * Extensible - Large ecosystem of community middleware and plugins

                                                Getting Started

                                                Prerequisites

                                                * Go version: Gin requires Go version 1.25 or above
                                                * Basic Go knowledge: Familiarity with Go syntax and package management is helpful

                                                Installation

                                              With Go's module support, simply import Gin in your code and Go will automatically fetch it during build:

                                                import "github.com/gin-gonic/gin"

                                                Your First Gin Application

                                              Here's a complete example that demonstrates Gin's simplicity:

                                                package main
                                                
                                                import (
                                                  "log"
                                                  "net/http"
                                                
                                                  "github.com/gin-gonic/gin"
                                                )
                                                
                                                func main() {
                                                  // Create a Gin router with default middleware (logger and recovery)
                                                  r := gin.Default()
                                                
                                                  // Define a simple GET endpoint
                                                  r.GET("/ping", func(c *gin.Context) {
                                                    // Return JSON response
                                                    c.JSON(http.StatusOK, gin.H{
                                                      "message": "pong",
                                                    })
                                                  })
                                                
                                                  // Start server on port 8080 (default)
                                                  // Server will listen on 0.0.0.0:8080 (localhost:8080 on Windows)
                                                  if err := r.Run(); err != nil {
                                                    log.Fatalf("failed to run server: %v", err)
                                                  }
                                                }

                                              Running the application:

                                               1. Save the code above as main.go

                                               2. Run the application:

                                                    go run main.go

                                               3. Open your browser and visit http://localhost:8080/ping

                                               4. You should see: {"message":"pong"}

                                              What this example demonstrates:

                                                * Creating a Gin router with default middleware
                                                * Defining HTTP endpoints with simple handler functions
                                                * Returning JSON responses
                                                * Starting an HTTP server

                                                Next Steps

                                              After running your first Gin application, explore these resources to learn more:

                                                📚 Learning Resources

                                                * Gin Quick Start Guide - Comprehensive tutorial with API examples and build configurations
                                                * Example Repository - Ready-to-run examples demonstrating various Gin use cases:
                                                    + REST API development
                                                    + Authentication & middleware
                                                    + File uploads and downloads
                                                    + WebSocket connections
                                                    + Template rendering

                                                📖 Documentation

                                                API Reference

                                                * Go.dev API Documentation - Complete API reference with examples

                                                User Guides

                                              The comprehensive documentation is available on gin-gonic.com in multiple languages:

                                                * English | 简体中文 | 繁體中文
                                                * 日本語 | 한국어 | Español
                                                * Turkish | Persian | Português
                                                * Russian | Indonesian

                                                Official Tutorials

                                                * Go.dev Tutorial: Developing a RESTful API with Go and Gin

                                                ⚡ Performance Benchmarks

                                              Gin demonstrates exceptional performance compared to other Go web frameworks. It uses a custom version of HttpRouter for maximum efficiency. View detailed benchmarks →

                                              Gin vs. Other Go Frameworks (GitHub API routing benchmark):

                                              Benchmark name                    (1)            (2)           (3)              (4)
                                              BenchmarkGin_GithubAll          43550    27364 ns/op        0 B/op      0 allocs/op
                                              BenchmarkAce_GithubAll          40543    29670 ns/op        0 B/op      0 allocs/op
                                              BenchmarkAero_GithubAll         57632    20648 ns/op        0 B/op      0 allocs/op
                                              BenchmarkBear_GithubAll          9234   216179 ns/op    86448 B/op    943 allocs/op
                                              BenchmarkBeego_GithubAll         7407   243496 ns/op    71456 B/op    609 allocs/op
                                              BenchmarkBone_GithubAll           420  2922835 ns/op   720160 B/op   8620 allocs/op
                                              BenchmarkChi_GithubAll           7620   238331 ns/op    87696 B/op    609 allocs/op
                                              BenchmarkDenco_GithubAll        18355    64494 ns/op    20224 B/op    167 allocs/op
                                              BenchmarkEcho_GithubAll         31251    38479 ns/op        0 B/op      0 allocs/op
                                              BenchmarkGocraftWeb_GithubAll    4117   300062 ns/op   131656 B/op   1686 allocs/op
                                              BenchmarkGoji_GithubAll          3274   416158 ns/op    56112 B/op    334 allocs/op
                                              BenchmarkGojiv2_GithubAll        1402   870518 ns/op   352720 B/op   4321 allocs/op
                                              BenchmarkGoJsonRest_GithubAll    2976   401507 ns/op   134371 B/op   2737 allocs/op
                                              BenchmarkGoRestful_GithubAll      410  2913158 ns/op   910144 B/op   2938 allocs/op
                                              BenchmarkGorillaMux_GithubAll     346  3384987 ns/op   251650 B/op   1994 allocs/op
                                              BenchmarkGowwwRouter_GithubAll  10000   143025 ns/op    72144 B/op    501 allocs/op
                                              BenchmarkHttpRouter_GithubAll   55938    21360 ns/op        0 B/op      0 allocs/op
                                              BenchmarkHttpTreeMux_GithubAll  10000   153944 ns/op    65856 B/op    671 allocs/op
                                              BenchmarkKocha_GithubAll        10000   106315 ns/op    23304 B/op    843 allocs/op
                                              BenchmarkLARS_GithubAll         47779    25084 ns/op        0 B/op      0 allocs/op
                                              BenchmarkMacaron_GithubAll       3266   371907 ns/op   149409 B/op   1624 allocs/op
                                              BenchmarkMartini_GithubAll        331  3444706 ns/op   226551 B/op   2325 allocs/op
                                              BenchmarkPat_GithubAll            273  4381818 ns/op  1483152 B/op  26963 allocs/op
                                              BenchmarkPossum_GithubAll       10000   164367 ns/op    84448 B/op    609 allocs/op
                                              BenchmarkR2router_GithubAll     10000   160220 ns/op    77328 B/op    979 allocs/op
                                              BenchmarkRivet_GithubAll        14625    82453 ns/op    16272 B/op    167 allocs/op
                                              BenchmarkTango_GithubAll         6255   279611 ns/op    63826 B/op   1618 allocs/op
                                              BenchmarkTigerTonic_GithubAll    2008   687874 ns/op   193856 B/op   4474 allocs/op
                                              BenchmarkTraffic_GithubAll        355  3478508 ns/op   820744 B/op  14114 allocs/op
                                              BenchmarkVulcan_GithubAll        6885   193333 ns/op    19894 B/op    609 allocs/op
                                              
                                                * (1): Total Repetitions achieved in constant time, higher means more confident result
                                                * (2): Single Repetition Duration (ns/op), lower is better
                                                * (3): Heap Memory (B/op), lower is better
                                                * (4): Average Allocations per Repetition (allocs/op), lower is better

                                                🔌 Middleware Ecosystem

                                              Gin has a rich ecosystem of middleware for common web development needs. Explore community-contributed middleware:

                                                * gin-contrib - Official middleware collection including:
                                                    + Authentication (JWT, Basic Auth, Sessions)
                                                    + CORS, Rate limiting, Compression
                                                    + Logging, Metrics, Tracing
                                                    + Static file serving, Template engines
                                                * gin-gonic/contrib - Additional community middleware

                                                🏢 Production Usage

                                              Gin powers many high-traffic applications and services in production:

                                                * gorush - High-performance push notification server
                                                * fnproject - Container-native, serverless platform
                                                * photoprism - AI-powered personal photo management
                                                * lura - Ultra-performant API Gateway framework
                                                * picfit - Real-time image processing server
                                                * dkron - Distributed job scheduling system

                                                🤝 Contributing

                                              Gin is the work of hundreds of contributors from around the world. We welcome and appreciate your contributions! See the full list of contributors.

                                                How to Contribute

                                                * 🐛 Report bugs - Help us identify and fix issues
                                                * 💡 Suggest features - Share your ideas for improvements
                                                * 📝 Improve documentation - Help make our docs clearer
                                                * 🔧 Submit code - Fix bugs or implement new features
                                                * 🧪 Write tests - Improve our test coverage

                                                Getting Started with Contributing

                                               1. Check out our CONTRIBUTING.md for detailed guidelines
                                               2. Join our community discussions and ask questions

                                              All contributions are valued and help make Gin better for everyone!

                                        About

                                        Gin is a high-performance HTTP web framework written in Go. It provides a Martini-like API but with significantly better performance—up to 40 times faster—thanks to httprouter. Gin is designed for building REST APIs, web applications, and microservices.

                                          gin-gonic.com/

                                        Topics

                                          frameworkgingomiddlewareperformancerouterserver

                                        Resources

                                          Readme
                                          MIT license

                                        Code of conduct

                                          Code of conduct

                                        Contributing

                                          Contributing
                                          Activity
                                          Custom properties

                                        Stars

                                          89.1k stars

                                        Watchers

                                          1.4k watching

                                        Forks

                                          8.7k forks
                                          Report repository

                                        Releases

                                        Packages

                                        Used by

                                        Contributors

                                        Languages

    Footer

        © 2026 GitHub, Inc.

      Footer navigation

        * Terms
        * Privacy
        * Security
        * Status
        * Community
        * Docs
        * Contact
        * Manage cookies
        * Do not share my personal information
      You can’t perform that action at this time.
На даний момент порівняння виконується за текстом, а не графічно; доступний лише останній скріншот.

Скріншот вимагає завантажувача контенту (Sockpuppetbrowser, selenium тощо), який підтримує створення скріншотів.