[Hinweis] [Anfänger] Schreiben, wenn der Wert eines Array-Elements in einem sich wiederholenden Satz von Ruby geändert wird

(ruby 2.5.3)

Fazit

Wenn Sie eine JavaScript-Wiederholungsanweisung drehen möchten, während Sie Änderungen an den Array-Elementen vornehmen

for (var i = 0; i < A.length; i++){
 // Ausgelassen: Ändere den Wert von A [i] unter bestimmten Bedingungen
}

Wenn Sie in Ruby in der gleichen Atmosphäre reproduzieren möchten

 A.each_index do |i|
 ## Ausgelassen: Ändern Sie unter bestimmten Bedingungen den Wert von A [i]
end

Ich werde schreiben.

Hintergrund

Ich habe meinen in JavaScript geschriebenen privaten Code in Ruby umgeschrieben. Die folgende JavaScript-Funktion ist ein Teil davon. Wenn englische Teile in einem Array übergeben werden, wird der Wortanfang, der dem Satzanfang entspricht, durch das Symbol am Ende in Großbuchstaben geändert und kombiniert und ausgegeben.

function Upcasing(result_lines) {
  result_lines[0] = result_lines[0].replace(/^[a-z]/, result_lines[0].charAt(0).toUpperCase() );
  var break_flg = false;
  const break_sign = { ".":true, "!":true, "?":true, ",":false };
  for (var i = 0; i < result_lines.length; i++) {
    if (break_flg === true) {
      result_lines[i] = result_lines[i].replace(/^[a-z]/, result_lines[i].charAt(0).toUpperCase() );
    }

    if ( break_sign[result_lines[i].slice(-1)] === true) {
      break_flg = true;
    } else {
      break_flg = false;
    }
  }
  return result_lines.join(" ");
}

console.log(Upcasing(["oh,", "yeah!", "hello!"]));

 // Ausführungsergebnis
// Oh, yeah! Hello!　
 // <= "Hallo!" Wird jetzt durch das vorherige "!"

Folgendes habe ich in die Ruby-Methode umgeschrieben (dachte ich).

def Upcasing(result_lines)
  result_lines[0] = result_lines[0].capitalize
  break_flg = false
  break_sign = { "."=>true, "!"=>true, "?"=>true, ","=>false }

  for r in result_lines
    if break_flg == true
      r = r.capitalize
    end

    if break_sign[r.slice(-1)] == true
      break_flg = true
    else
      break_flg = false
    end
  end
  joined_line = result_lines.join(" ")
  return joined_line
end

print Upcasing(["oh,", "yeah!", "hello!"])

## Ausführungsergebnis
## Oh ja! Hallo! <= "H" in "Hallo!" Wird nicht groß geschrieben

Da das for expression` `keinen Bereich wie das` `each method erstellt, kann das r des` `for r in result_lines außerhalb des Blocks verwendet werden, aber in erster Linie ist es das ursprüngliche Array-Element. Ist eine neu definierte Variable. Wenn Sie also Änderungen an Array-Elementen vornehmen möchten, müssen Sie results_lines [i] sogar innerhalb des Blocks bearbeiten. (Diese Variable r ist kein Blockparameter.)

Normalerweise gibt es beim Schreiben von Ruby-Code nicht viele Szenen, in denen Werte in sich wiederholenden Blöcken zugewiesen werden. Daher fehlt das Konzept temporärer Felder wie Blockparameter und die Erkennung des generierten Bereichs. Es war.

(* Das in diesem Memorandum verwendete ist Ruby 2.5.3.)

In der Form von "für Variablennamen in Arraynamen" wie im obigen Code ist der Index für die Angabe des Array-Elements im Block nicht in der Variablen definiert. Verwenden Sie daher die Methode "each_index" und verwenden Sie Folgendes Gewechselt zu. (Der folgende Code wurde in einem Artikel überarbeitet, der zu einem späteren Zeitpunkt veröffentlicht wurde.)

def Upcasing(result_lines)
  result_lines[0] = result_lines[0].capitalize
  break_flg = false
  break_sign = { "."=>true, "!"=>true, "?"=>true, ","=>false }

   result_lines.each_index do |i|
    if break_flg == true
      result_lines[i] = result_lines[i].capitalize
    end

    if break_sign[result_lines[i].slice(-1)] == true
      break_flg = true
    else
      break_flg = false
    end
  end
  joined_line = result_lines.join(" ")
  return joined_line
end

print Upcasing(["oh,", "yeah!", "hello!"])

## Ausführungsergebnis
 Oh, yeah! Hello!

(In diesem Fall gibt es keine Auswirkung auf das Ganze, da es nicht erforderlich ist, die im Wiederholungsblock außerhalb des Variablenblocks definierte Variable zu verwenden, je nachdem, ob der Bereich durch "für Ausdruck" oder "jede Methode" generiert wird. .)

Impressionen

Ich denke, dass das Weglassen des Variablennamens und das Reduzieren der Anzahl von Sätzen ein großer Vorteil der Verwendung des Blockparameters ist, aber wenn das relevante Array-Element im iterativen Prozess geändert wird, wird es möglicherweise nicht viel verwendet. Ich habe darüber nachgedacht, den Wert und den Index mit der Methode "each_with_index" an den Blockparameter zu übergeben und ihn nur in dem Teil zu verwenden, der sich auf das aktuelle Element bezieht, wie im folgenden Entwurf, aber ich bin der Meinung, dass Schreibfehler zunehmen können. Und blieb stehen. Der Variablenname lautet| r |Nicht| current_element |Es kann immer noch leicht zu verstehen sein.

result_lines.each_with_index do |current_element, i|
 if break_flg == true
   result_lines[i] = current_element.capitalize
 end

 if break_sign[current_element.slice(-1)] == true
   break_flg = true
 else
   break_flg = false
 end
end

each_with_index (* args) -> Enumerator | Ruby 2.7.0 Referenzhandbuch