ruby-on-rails - operador - porcentaje en ruby

Primer indicador mágico y último en un bucle en Ruby/Rails?

Question

Ruby / Rails hace muchas cosas geniales cuando se trata de azúcar para cosas básicas, y creo que hay un escenario muy común en el que me pregunto si alguien ha hecho alguna ayuda o algo similar.

   a = Array.new(5, 1)

   a.each_with_index do |x, i|
     if i == 0
       print x+1
     elsif i == (a.length - 1)
       print x*10
     else
        print x
     end
   end

Perdonen la fealdad, pero esto llega a lo que uno podría desear ... ¿hay alguna manera de hacer algo con Ruby en el primer y último ciclo?

[EDIT] Creo que idealmente sería una extensión en Array con parámetros (instancia de matriz, función de todos los elementos, función de los primeros elementos, función de los últimos elementos) ... pero estoy abierto a otros pensamientos.

Answer 1

¿Qué pasaría si pudieras hacer esto?

%w(a b c d).each.with_position do |e, position|
  p [e, position]    # => ["a", :first]
                     # => ["b", :middle]
                     # => ["c", :middle]
                     # => ["d", :last]
end

¿O esto?

%w(a, b, c, d).each_with_index.with_position do |(e, index), position|
  p [e, index, position]    # => ["a,", 0, :first]
                            # => ["b,", 1, :middle]
                            # => ["c,", 2, :middle]
                            # => ["d", 3, :last]
end

En MRI> = 1.8.7, todo lo que se necesita es este parche de mono:

class Enumerable::Enumerator

  def with_position(&block)
    state = :init
    e = nil
    begin
      e_last = e
      e = self.next
      case state
      when :init
        state = :first
      when :first
        block.call(e_last, :first)
        state = :middle
      when :middle
        block.call(e_last, :middle)
      end
    rescue StopIteration
      case state
      when :first
        block.call(e_last, :first)
      when :middle
        block.call(e_last, :last)
      end
      return
    end while true
  end

end

Tiene un pequeño motor de estado porque debe mirar hacia adelante una iteración.

El truco es que cada uno, cada_con_index, & c. devuelve un Enumerador si no tiene bloque. Los enumeradores hacen todo lo que hace un Enumerable y un poco más. Pero para nosotros, lo importante es que podemos aplicar un parche a Enumerator para agregar una forma más de iterar, "envolviendo" la iteración existente, sea lo que sea.

Answer 2

A veces un bucle for es solo tu mejor opción

if(array.count > 0)
   first= array[0]
   #... do something with the first

   cx = array.count -2 #so we skip the last record on a 0 based array
   for x in 1..cx
     middle = array[x]
     #... do something to the middle
   end

   last = array[array.count-1]
   #... do something with the last item. 
end

Sé que esta pregunta fue respondida, pero este método no tiene efectos secundarios y no verifica si el registro 13º, 14º, 15º ... 10º.OOO, 10.001º es el primer registro, o el último.

Las respuestas anteriores habrían fallado la asignación en cualquier clase de estructura de datos.

Answer 3

BESO

arr.each.with_index do |obj, index|
  p ''first'' if index == 0        
  p ''last'' if index == arr.count-1                  
end

Answer 4

Como muchos han señalado, each_with_index parece ser la clave para esto. Tengo este bloque de código que me gustó.

array.each_with_index do |item,index|
  if index == 0
    # first item
  elsif index == array.length-1
    # last item
  else
    # middle items
  end
  # all items
end

O

array.each_with_index do |item,index|
  if index == 0
    # first item
  end
  # all items
  if index == array.length-1
    # last item
  end
end

O por extensiones Array

class Array

  def each_with_position
    array.each_with_index do |item,index|
      if index == 0
        yield item, :first
      elsif index == array.length-1
        yield item, :last
      else
        yield item, :middle
      end
    end
  end

  def each_with_index_and_position
    array.each_with_index do |item,index|
      if index == 0
        yield item, index, :first
      elsif index == array.length-1
        yield item, index, :last
      else
        yield item, index, :middle
      end
    end
  end

  def each_with_position_and_index
    array.each_with_index do |item,index|
      if index == 0
        yield item, :first, index
      elsif index == array.length-1
        yield item, :last, index
      else
        yield item, :middle, index
      end
    end
  end

end

Answer 5

Necesitaba esta funcionalidad de vez en cuando, así que diseñé una pequeña clase para ese propósito.

La última versión está en: https://gist.github.com/3823837

Muestra:

("a".."m").to_a.each_pos do |e|
  puts "Char/tfirst?/tlast?/tprev/tnext/twrapped?/tindex/tposition" if e.first?
  print "#{e.item}/t"
  print "#{e.first?}/t"
  print "#{e.last?}/t"
  print "#{e.prev}/t"
  print "#{e.next}/t"
  print "#{e.wrapped?}/t/t"
  print "#{e.index}/t"
  puts  "#{e.position}/t"
end

# Char  first?  last?  prev  next  wrapped?  index  position
# a     true    false        b     false     0      1
# b     false   false  a     c     true      1      2
# c     false   false  b     d     true      2      3
# d     false   false  c     e     true      3      4
# e     false   false  d     f     true      4      5
# f     false   false  e     g     true      5      6
# g     false   false  f     h     true      6      7
# h     false   false  g     i     true      7      8
# i     false   false  h     j     true      8      9
# j     false   false  i     k     true      9      10
# k     false   false  j     l     true      10     11
# l     false   false  k     m     true      11     12
# m     false   true   l           false     12     13



{
  a: "0",
  b: "1",
  c: "2",
  d: "3",
  e: "4",
  f: "5",
  g: "6",
  h: "7",
  i: "8",
  j: "9",
  k: "10",
  l: "11",
  m: "12",
}.each_pos do |(k, v), e|
  puts "KV/tChar/t/tfirst?/tlast?/tprev/t/tnext/t/twrapped?/tindex/tposition" if e.first?
  print "#{k} => #{v}/t"
  print "#{e.item}/t"
  print "#{e.first?}/t"
  print "#{e.last?}/t"
  print "#{e.prev || "/t"}/t"
  print "#{e.next || "/t"}/t"
  print "#{e.wrapped?}/t/t"
  print "#{e.index}/t"
  puts  "#{e.position}/t"
end

# KV      Char        first?  last?   prev        next        wrapped?  index position
# a => 0  [:a, "0"]   true    false               [:b, "1"]   false     0     1
# b => 1  [:b, "1"]   false   false   [:a, "0"]   [:c, "2"]   true      1     2
# c => 2  [:c, "2"]   false   false   [:b, "1"]   [:d, "3"]   true      2     3
# d => 3  [:d, "3"]   false   false   [:c, "2"]   [:e, "4"]   true      3     4
# e => 4  [:e, "4"]   false   false   [:d, "3"]   [:f, "5"]   true      4     5
# f => 5  [:f, "5"]   false   false   [:e, "4"]   [:g, "6"]   true      5     6
# g => 6  [:g, "6"]   false   false   [:f, "5"]   [:h, "7"]   true      6     7
# h => 7  [:h, "7"]   false   false   [:g, "6"]   [:i, "8"]   true      7     8
# i => 8  [:i, "8"]   false   false   [:h, "7"]   [:j, "9"]   true      8     9
# j => 9  [:j, "9"]   false   false   [:i, "8"]   [:k, "10"]  true      9     10
# k => 10 [:k, "10"]  false   false   [:j, "9"]   [:l, "11"]  true      10    11
# l => 11 [:l, "11"]  false   false   [:k, "10"]  [:m, "12"]  true      11    12
# m => 12 [:m, "12"]  false   true    [:l, "11"]              false     12    13

Clase real:

module Enumerable
  # your each_with_position method
  def each_pos &block
    EachWithPosition.each(self, &block)
  end
end

class EachWithPosition
  attr_reader :index

  class << self
    def each *a, &b
      handler = self.new(*a, :each, &b)
    end
  end

  def initialize collection, method, &block
    @index = 0
    @item, @prev, @next = nil
    @collection = collection
    @callback = block
    self.send(method)
  end

  def count
    @collection.count
  end
  alias_method :length, :count
  alias_method :size, :count

  def rest
    count - position
  end

  def first?
    @index == 0
  end

  def last?
    @index == (count - 1)
  end

  def wrapped?
    !first? && !last?
  end
  alias_method :inner?, :wrapped?

  def position
    @index + 1
  end

  def prev
    @prev
  end

  def next
    @next
  end

  def current
    @item
  end
  alias_method :item, :current
  alias_method :value, :current

  def call
    if @callback.arity == 1
      @callback.call(self)
    else
      @callback.call(@item, self)
    end
  end

  def each
    @collection.each_cons(2) do |e, n|
      @prev = @item
      @item = e
      @next = n

      self.call
      @index += 1

      # fix cons slice behaviour
      if last?
        @prev, @item, @next = @item, @next, nil
        self.call
        @index += 1
      end
    end
  end
end

Answer 6

No existe la sintaxis "do this the time (first | last) time" en Ruby. Pero si buscas concisión, podrías hacer esto:

a.each_with_index do |x, i|
  print (i > 0 ? (i == a.length - 1 ? x*10 : x) : x+1)
end

El resultado es lo que esperarías:

irb(main):001:0> a = Array.new(5,1)
=> [1, 1, 1, 1, 1]
irb(main):002:0> a.each_with_index do |x,i|
irb(main):003:1*   puts (i > 0 ? (i == a.length - 1 ? x*10 : x) : x+1)
irb(main):004:1> end
2
1
1
1
10

Answer 7

No pude resistir :) Esto no está ajustado para el rendimiento, aunque supongo que no debería ser mucho más lento que la mayoría de las otras respuestas aquí. ¡Todo se trata del azúcar!

class Array
  class EachDSL
    attr_accessor :idx, :max

    def initialize arr
      self.max = arr.size
    end

    def pos
      idx + 1
    end

    def inside? range
      range.include? pos
    end

    def nth? i
      pos == i
    end

    def first?
      nth? 1
    end

    def middle?
      not first? and not last?
    end

    def last?
      nth? max
    end

    def inside range
      yield if inside? range
    end

    def nth i
      yield if nth? i
    end

    def first
      yield if first?
    end

    def middle
      yield if middle?
    end

    def last
      yield if last?
    end
  end

  def each2 &block
    dsl = EachDSL.new self
    each_with_index do |x,i|
      dsl.idx = i
      dsl.instance_exec x, &block
    end
  end
end

Ejemplo 1:

[1,2,3,4,5].each2 do |x|
  puts "#{x} is first"  if first?
  puts "#{x} is third"  if nth? 3
  puts "#{x} is middle" if middle?
  puts "#{x} is last"   if last?
  puts
end

# 1 is first
# 
# 2 is middle
# 
# 3 is third
# 3 is middle
# 
# 4 is middle
# 
# 5 is last

Ejemplo 2:

%w{some short simple words}.each2 do |x|
  first do
    puts "#{x} is first"
  end

  inside 2..3 do
    puts "#{x} is second or third"
  end

  middle do
    puts "#{x} is middle"
  end

  last do
    puts "#{x} is last"
  end
end

# some is first
# short is second or third
# short is middle
# simple is second or third
# simple is middle
# words is last

Answer 8

O un pequeño pequeño lenguaje específico del dominio:

a = [1, 2, 3, 4]

FirstMiddleLast.iterate(a) do
  first do |e|
    p [e, ''first'']
  end
  middle do |e|
    p [e, ''middle'']
  end
  last do |e|
    p [e, ''last'']
  end
end

# => [1, "first"]
# => [2, "middle"]
# => [3, "middle"]
# => [4, "last"]

y el código que lo hace funcionar:

class FirstMiddleLast

  def self.iterate(array, &block)
    fml = FirstMiddleLast.new(array)
    fml.instance_eval(&block)
    fml.iterate
  end

  attr_reader :first, :middle, :last

  def initialize(array)
    @array = array
  end

  def first(&block)
    @first = block
  end

  def middle(&block)
    @middle = block
  end

  def last(&block)
    @last = block
  end

  def iterate
    @first.call(@array.first) unless @array.empty?
    if @array.size > 1
      @array[1..-2].each do |e|
        @middle.call(e)
      end
      @last.call(@array.last)
    end
  end

end

Empecé a pensar, "si solo pudieras pasar múltiples bloques a una función de Ruby, entonces podrías tener una solución fácil y lisa para esta pregunta". Luego me di cuenta de que los DSL juegan pequeños trucos que son casi como pasar múltiples bloques.

Answer 9

Particione la matriz en rangos donde se supone que los elementos dentro de cada rango se comporten de manera diferente. Asigne cada rango así creado a un bloque.

class PartitionEnumerator
    include RangeMaker

    def initialize(array)
        @array = array
        @handlers = {}
    end

    def add(range, handler)
        @handlers[range] = handler
    end

    def iterate
        @handlers.each_pair do |range, handler|
          @array[range].each { |value| puts handler.call(value) }
        end
    end
end

Podría crear rangos a mano, pero estos ayudantes a continuación lo hacen más fácil:

module RangeMaker
  def create_range(s)
    last_index = @array.size - 1
    indexes = (0..last_index)
    return (indexes.first..indexes.first) if s == :first
    return (indexes.second..indexes.second_last) if s == :middle
    return (indexes.last..indexes.last) if s == :last
  end  
end

class Range
  def second
    self.first + 1
  end

  def second_last
    self.last - 1
  end
end

Uso:

a = [1, 2, 3, 4, 5, 6]

e = PartitionEnumerator.new(a)
e.add(e.create_range(:first), Proc.new { |x| x + 1 } )
e.add(e.create_range(:middle), Proc.new { |x| x * 10 } )
e.add(e.create_range(:last), Proc.new { |x| x } )

e.iterate

Answer 10

Podría tomar los primeros y últimos elementos y procesarlos de manera diferente, si lo desea.

first = array.shift
last = array.pop
process_first_one
array.each { |x| process_middle_bits }
process_last_one

Answer 11

Pregunta interesante, y una que he pensado un poco también.

Creo que tendrías que crear tres bloques / procs / lo que se llame, y luego crear un método que llame al bloque / proc / lo que sea correcto. (Perdón por la imprecisión - todavía no soy un metaprogramador de cinturón negro) [ Editar : sin embargo, he copiado de alguien que está en la parte inferior)

class FancyArray
  def initialize(array)
    @boring_array = array
    @first_code = nil
    @main_code = nil
    @last_code = nil
  end

  def set_first_code(&code)
    @first_code = code
  end

  def set_main_code(&code)
    @main_code = code
  end

  def set_last_code(&code)
    @last_code = code
  end

  def run_fancy_loop
    @boring_array.each_with_index do |item, i|
      case i
      when 0 then @first_code.call(item)
      when @boring_array.size - 1 then @last_code.call(item)
      else @main_code.call(item)
      end
    end
  end
end

fancy_array = FancyArray.new(["Matti Nykanen", "Erik Johnsen", "Michael Edwards"])
fancy_array.set_first_code {|item| puts "#{item} came first in ski jumping at the 1988 Winter Olympics"}
fancy_array.set_main_code {|item| puts "#{item} did not come first or last in ski jumping at the 1988 Winter Olympics"}
fancy_array.set_last_code {|item| puts "#{item} came last in ski jumping at the 1988 Winter Olympics"}
fancy_array.run_fancy_loop

produce

Matti Nykanen came first in ski jumping at the 1988 Winter Olympics
Erik Johnsen did not come first or last in ski jumping at the 1988 Winter Olympics
Michael Edwards came last in ski jumping at the 1988 Winter Olympics

Editar : la answer de Svante (con la sugerencia de molf) a una pregunta relacionada muestra cómo pasar múltiples bloques de código a un único método:

class FancierArray < Array
  def each_with_first_last(first_code, main_code, last_code)
    each_with_index do |item, i|
      case i
        when 0 then first_code.call(item)
        when size - 1 then last_code.call(item)
        else main_code.call(item)
      end
    end
  end
end

fancier_array = FancierArray.new(["Matti Nykanen", "Erik Johnsen", "Michael Edwards"])
fancier_array.each_with_first_last(
  lambda {|person| puts "#{person} came first in ski jumping at the 1988 Winter Olympics"},
  lambda {|person| puts "#{person} did not come first or last in ski jumping at the 1988 Winter Olympics"},
  lambda {|person| puts "#{person} came last in ski jumping at the 1988 Winter Olympics"})

Answer 12

Si el código para la primera y última iteración no tiene nada en común con el código para las otras iteraciones, también podría hacer:

do_something( a.first )
a[1..-2].each do |x|
  do_something_else( x )
end
do_something_else_else( a.last )

Si los diferentes casos tienen algún código en común, tu camino está bien.

Answer 13

Si está dispuesto a agregar un texto estándar, puede agregar algo como esto a la clase de matriz:

class Array
  def each_fl
    each_with_index do |x,i|
      yield [i==0 ? :first : (i==length-1 ? :last : :inner), x]
    end
  end
end

y luego en cualquier lugar que necesites, obtienes la siguiente sintaxis:

[1,2,3,4].each_fl do |t,x|
  case t
    when :first
      puts "first: #{x}"
    when :last
      puts "last: #{x}"
    else
      puts "otherwise: #{x}"
  end
end

para el siguiente resultado:

first: 1
otherwise: 2
otherwise: 3
last: 4

Answer 14

Si no te importa que la "última" acción ocurra antes del material en el medio, entonces este parche de mono:

class Array

  def for_first
    return self if empty?
    yield(first)
    self[1..-1]
  end

  def for_last
    return self if empty?
    yield(last)
    self[0...-1]
  end

end

Permite esto:

%w(a b c d).for_first do |e|
  p [''first'', e]
end.for_last do |e|
  p [''last'', e]
end.each do |e|
  p [''middle'', e]
end

# => ["first", "a"]
# => ["last", "d"]
# => ["middle", "b"]
# => ["middle", "c"]

Answer 15

Si sabe que los elementos del conjunto son únicos (a diferencia de este caso), puede hacer esto:

a = [1,2,3,4,5]

a.each_with_index do |x, i|
  if x == a.first
    print x+1
  elsif x == a.last
    print x*10
  else
    print x
  end
end

Answer 16

Veo muchos hacks aquí que están bastante cerca, pero todos dependen en gran medida de que el iterador dado tenga un tamaño fijo y NO sea un iterador. También me gustaría proponer guardar el elemento anterior a medida que avanzas para conocer el primer / último elemento que se repitió.

previous = {}
elements.each do |element|
  unless previous.has_key?(:element)
    # will only execute the first time
  end

  # normal each block here

  previous[:element] = element
end

# the last element will be stored in previous[:element]