Detectar lenguaje de programación a partir de un fragmento

La guía o código que hallarás en este post es la resolución más fácil y válida que hallamos a tu duda o dilema.

Solución:

Creo que el método utilizado en los filtros de spam funcionaría muy bien. Divides el fragmento en palabras. Luego, compara las apariciones de estas palabras con fragmentos conocidos y calcula la probabilidad de que este fragmento esté escrito en el idioma X para cada idioma que le interese.

http://en.wikipedia.org/wiki/Bayesian_spam_filtering

Si tiene el mecanismo básico, entonces es muy fácil agregar nuevos idiomas: simplemente entrene al detector con algunos fragmentos en el nuevo idioma (podría alimentarlo con un proyecto de código abierto). De esta manera, aprende que es probable que “Sistema” aparezca en fragmentos de C# y “puts” en fragmentos de Ruby.

De hecho, he usado este método para agregar detección de idioma a fragmentos de código para el software del foro. Funcionó el 100% del tiempo, excepto en casos ambiguos:

print "Hello"

Déjame encontrar el código.

No pude encontrar el código, así que hice uno nuevo. Es un poco simplista pero funciona para mis pruebas. Actualmente, si lo alimenta con mucho más código Python que código Ruby, es probable que diga que este código:

def foo
   puts "hi"
end

es código Python (aunque en realidad es Ruby). Esto se debe a que Python tiene un def palabra clave también. Así que si ha visto 1000x def en Python y 100x def en Ruby, entonces todavía puede decir Python aunque puts y end es específico de Ruby. Puede solucionar esto haciendo un seguimiento de las palabras vistas por idioma y dividiéndolas en algún lugar (o introduciendo cantidades iguales de código en cada idioma).

Espero que te ayude:

class Classifier
  def initialize
    @data = 
    @totals = Hash.new(1)
  end

  def words(code)
    code.split(/[^a-z]/).reject w.empty?
  end

  def train(code,lang)
    @totals[lang] += 1
    @data[lang] ||= Hash.new(1)
    words(code).each w
  end

  def classify(code)
    ws = words(code)
    @data.keys.max_by do |lang|
      # We really want to multiply here but I use logs 
      # to avoid floating point underflow
      # (adding logs is equivalent to multiplication)
      Math.log(@totals[lang]) +
      ws.map Math.log(@data[lang][w]).reduce(:+)
    end
  end
end

# Example usage

c = Classifier.new

# Train from files
c.train(open("code.rb").read, :ruby)
c.train(open("code.py").read, :python)
c.train(open("code.cs").read, :csharp)

# Test it on another file
c.classify(open("code2.py").read) # => :python (hopefully)

Detección de idioma resuelta por otros:

El enfoque de Ohloh: https://github.com/blackducksw/ohcount/

El enfoque de Github: https://github.com/github/linguist

Guesslang es una posible solución:

http://guesslang.readthedocs.io/en/latest/index.html

También hay SourceClassifier:

https://github.com/chrislo/sourceclassifier/tree/maestro

Me interesé en este problema después de encontrar un código en un artículo de blog que no pude identificar. Agregar esta respuesta ya que esta pregunta fue el primer resultado de búsqueda de “identificar lenguaje de programación”.

valoraciones y reseñas

Finalizando este artículo puedes encontrar las ilustraciones de otros programadores, tú igualmente eres capaz insertar el tuyo si te gusta.

---

---

Utiliza Nuestro Buscador