2010-11-12 17 views

Respuesta

214
puts 'abcdefg'.start_with?('abc') #=> true 

[editar] Esto es algo que no sabía antes de esta pregunta: start_with toma varios argumentos.

'abcdefg'.start_with?('xyz', 'opq', 'ab') 
+1

MRI no lo hace tiene 'start_with?', pero MRI 1.9 lo hace, al igual que Rails. –

+0

@Wayne Conrad: Extrañamente, 1.8.7 * does * tiene la documentación de ['String # start_with?'] (Http://RubyDoc.Info/docs/ruby-core/1.8.7/String#start_with%3F- ejemplo_metodo). –

+0

@ Jörg W Mittag, quizás no extrañamente, estaba equivocado. MRI 1.8.7 sí tiene 'start_with?'. Supongo que lo escribí cuando cargué el IRB para probarlo. –

4

El método mencionado por steenslag es escueto, y dado el alcance de la pregunta, se debe considerar la respuesta correcta. Sin embargo, también vale la pena saber que esto se puede lograr con una expresión regular, que si no estás familiarizado con Ruby, es una habilidad importante para aprender.

tener un juego con Rubular: http://rubular.com/

Pero en este caso, la siguiente declaración de rubí devolverá true si la cadena de la izquierda comienza con 'abc'. El \ A en el literal de expresión regular a la derecha significa 'el comienzo de la cadena'. Juega con rublos: quedará claro cómo funcionan las cosas.

'abcdefg' =~ /\Aabc/ 
+0

Como señaló Wayne Conrad, este método también funcionará en una variedad más amplia de tiempos de ejecución que start_with will. – pakeha

2

me gusta

if ('string'[/^str/]) ... 
+6

Debería usar '[/ \ Astr /]' aquí. Su expresión regular también coincide con '" otra \ nstring "'. – haslo

49

Puesto que hay varios métodos que se presentan aquí, quería averiguar cuál fue el más rápido. El uso de Ruby 1.9.3p362:

irb(main):001:0> require 'benchmark' 
=> true 
irb(main):002:0> Benchmark.realtime { 1.upto(10000000) { "foobar"[/\Afoo/] }} 
=> 12.477248 
irb(main):003:0> Benchmark.realtime { 1.upto(10000000) { "foobar" =~ /\Afoo/ }} 
=> 9.593959 
irb(main):004:0> Benchmark.realtime { 1.upto(10000000) { "foobar"["foo"] }} 
=> 9.086909 
irb(main):005:0> Benchmark.realtime { 1.upto(10000000) { "foobar".start_with?("foo") }} 
=> 6.973697 

Así que parece que no está en el más rápido de todos.

Los resultados actualizados con Rubí 2.2.2p95 y una nueva máquina:

require 'benchmark' 
Benchmark.bm do |x| 
    x.report('regex[]') { 10000000.times { "foobar"[/\Afoo/] }} 
    x.report('regex')  { 10000000.times { "foobar" =~ /\Afoo/ }} 
    x.report('[]')   { 10000000.times { "foobar"["foo"] }} 
    x.report('start_with') { 10000000.times { "foobar".start_with?("foo") }} 
end 

      user  system  total  real 
regex[]  4.020000 0.000000 4.020000 ( 4.024469) 
regex  3.160000 0.000000 3.160000 ( 3.159543) 
[]   2.930000 0.000000 2.930000 ( 2.931889) 
start_with 2.010000 0.000000 2.010000 ( 2.008162) 
+4

no es sorprendente dado que compilar y probar expresiones regulares es mucho más difícil que simplemente comparar bytes – akostadinov

+1

Cabe señalar que Regex es muy superior para búsquedas que no distinguen entre mayúsculas y minúsculas, incluso si calculó todas las permutaciones de casos para la cadena de prueba con anticipación. –

+2

@PeterP. Acabo de probar búsquedas que no distinguen entre mayúsculas y minúsculas y start_with? aún sale adelante si solo descifra la cadena para buscar y luego compara con la cadena de búsqueda minúscula: '" FooBar ".downcase.start_with? (" foo ")'. – haslo

Cuestiones relacionadas