Função para validar Renavam, Valida Renavam, Verifica Renavam

validarRenavam.js

/**
 * Função para validar sequencia de digitos de Renavam  
 * 
 * @link http://blog.victorjabur.com/2010/05/28/renavam_veiculos_java/ Função baseada em uma de java retirada desse link
 * @param string|int renavam Sequencia de digitos do renavam
 * @return boolean
 */
function verificaRenavam( renavam ) {

  var d = renavam.split("");
  soma = 0,
  valor = 0,
  digito = 0,
  x = 0;

  for (var i = 5; i >= 2; i--) {
    soma += d[x] * i;
    x++;
  }

  valor = soma % 11;

  if (valor == 11 || valor == 0 || valor >= 10) {
    digito = 0;
  } else {
    digito = valor;
  }

  if (digito == d[4]) {
    return true;
  } else {
    return false;
  }
}

console.log('197073212');

validarRenavam.php

<php
/**
 * Função para validar sequencia de digitos de Renavam  
 * 
 * @link http://blog.victorjabur.com/2010/05/28/renavam_veiculos_java/ Função baseada em uma de java retirada desse link
 * @param string|int $renavam Sequencia de digitos do renavam
 * @return boolean
 */
function validaRenavam ( $renavam ) {
	$soma = 0;
	// Cria array com as posições da string
	$d = str_split($renavam);
	$x = 0;
	$digito = 0;

	// Calcula os 4 primeiros digitos do renavam fazendo o calculo da primeira posição do array * 5 e vai diminuindo até chegar a 2
	for ($i=5; $i >= 2; $i--) { 
		$soma += $d[$x] * $i;
		$x++;
	}

	// Faz o calculo de 11
	$valor = $soma % 11;

	// Busca digito verificador
	if ($valor == 11 || $valor == 0 || $valor >= 10) {	
		$digito = 0;
	} else {
		$digito = $valor;
	}

	// Verifica digito com a 5 posição do array
	if ($digito == $d[4]) {
		return 1;
	} else {
		return 0;
	}
}

echo "<pre>";
var_dump(validaRenavam('197073212'));
exit;

Validador em PHP (>= 8.0.0), implementando interface ValidationRule do Laravel 11, baseado no código em https://victorjabur.com/2010/05/28/renavam_veiculos_java

<?php

namespace App\Rules;

use Closure;
use Illuminate\Contracts\Validation\ValidationRule;

class Renavam implements ValidationRule
{
    /**
     * Run the validation rule.
     *
     * @param  \Closure(string, ?string=): \Illuminate\Translation\PotentiallyTranslatedString  $fail
     */
    public function validate(string $attribute, mixed $value, Closure $fail): void
    {
        if (!is_string($value)) {
            $fail('Must be a string');
        }

        if (!is_numeric($value)) {
            $fail('Must have only numbers');
        }

        $value = str_pad($value, 11, '0', STR_PAD_LEFT);

        if (strlen($value) !== 11) {
            $fail('Must have exactly 11 numbers');
        }

        [$numeros, $validador] = str_split($value, 10);

        if ($this->calcularDigitos($numeros) !== $validador) {
            $fail('Invalid Renavam');
        }
    }

    private function calcularDigitos(string $numeros): string
    {
        $primeiro = $this->calcularDigitoUnico($numeros);

        return '' . $primeiro;
    }

    private function calcularDigitoUnico(string $numeros): int
    {
        $numeros = strrev($numeros);
        $length = strlen($numeros);

        $sum = 0;
        for ($i = 0; $i < $length; $i++) {
            $sum += intval($numeros[$i]) * (2 + $i % 8);
        }

        $mod = $sum % 11;
        return $mod < 2 ? 0 : 11 - $mod;
    }
}

A lógica é igual à do CNPJ, diferindo apenas no tamanho do número e quantidade de dígitos verificadores.

Codei o exemplo a cima em Go

package main

import (
	"fmt"
	"regexp"
	"strconv"
	"strings"
)

func IsValidRenavam(input string) bool {
	renavam := strings.TrimSpace(input)
	renavam = normalizeOlderRenavam(renavam)

	if !regexp.MustCompile(`^\d{11}$`).MatchString(renavam) {
		return false
	}

	base := reverseString(renavam[:10])
	multiplicadores := []int{2, 3, 4, 5, 6, 7, 8, 9, 2, 3}

	soma := 0
	for i := 0; i < 10; i++ {
		num, _ := strconv.Atoi(string(base[i]))
		soma += num * multiplicadores[i]
	}

	resto := soma % 11
	digitoCalculado := 11 - resto
	if digitoCalculado >= 10 {
		digitoCalculado = 0
	}

	digitoInformado, _ := strconv.Atoi(string(renavam[10]))
	return digitoCalculado == digitoInformado
}

func normalizeOlderRenavam(renavam string) string {
	if regexp.MustCompile(`^\d{9}$`).MatchString(renavam) {
		return "00" + renavam
	}
	return renavam
}

func reverseString(s string) string {
	r := []rune(s)
	for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
		r[i], r[j] = r[j], r[i]
	}
	return string(r)
}

func main() {
	// Exemplos de uso
	fmt.Println(IsValidRenavam("77338872602")) // true
	fmt.Println(IsValidRenavam("12345678909")) // false
	fmt.Println(IsValidRenavam("65306981534")) // true
	fmt.Println(IsValidRenavam("05115024925")) // false
}

use o playgorund de Go para testar: https://go.dev/play/