Wie finden Sie die Höhe zwischen parant div oben nach child-div-top in javascript?

Hier, ich habe zwei div-und Eltern-div in div Kind, und dieses Kind div dynamisch ist und scrollbare so möchte ich finden, der Höhe, der Entfernung zwischen Ihnen mit javascript, wie es möglich ist ? (Ich habe versucht mit folgenden code und gedruckt die Konsole, aber in der Konsole bekam ich mit der Höhe 0)

const parentDiv = document.getElementById('parent-div-id');
const childDiv = document.getElementById('child-div-id');
console.log('childDiv', childDiv.offsetTop);
<div id="parent-div-id">
   <div id="child-div-id">
      Some content..
   </div>
</div>
   
     

0
2019-09-17 10:27:48
Quelle
7 Antworten

Meine beste Vermutung (einfach zu groß für einen Kommentar, plus ich habe keine Erfahrung mit Kafka) :

JDBC ist standardmäßig unabhängig von der Isolationsstufe der Datenbank standardmäßig. Für Postgres, ist, dass die READ COMMITTED - aus https://www.postgresql.org/docs/9.5/transaction-iso.html (Hervorhebung von mir) :

Read Committed is the default isolation level in PostgreSQL. When a transaction uses this isolation level, a SELECT query (without a FOR UPDATE/SHARE clause) sees only data committed before the query began; it never sees either uncommitted data or changes committed during query execution by concurrent transactions.

Jetzt schauen wir uns Ihre Kafka-Verbindung. Standardmäßig Kafka läuft mit verpflichtet alle 5 Sekunden https://medium.com/@danieljameskay/understanding-the-enable-auto-commit-kafka-consumer-property-12fa0ade7b65

The first property enable.auto.commit has a default value of true and the second property auto.commit.interval.ms has a default value of 5000. These values are correct for Blizzards node-rdkafka client and the Java KafkaConsumer client but other libraries may differ.

So by default every 5 seconds a Consumer is going to commit its Offset to Kafka or every time data is fetched from the specified Topic it will commit the latest Offset.

So Kafkas Verwendung des Begriffs "Auto-Commit" wird die SQL - /JDBC-Bedeutung von "nach jeder Anweisung, dh jedes statement in einer eigenen Transaktion". Vielmehr Kafka scheint die Verwendung von "Auto-Commit" als Kafka mit offenen Transaktionen, es wird automatisch alle 5 Sekunden Begehen. So, da Kafka Lesen mit Datenbank-Transaktionen dauert 5 Sekunden, dann in pro LESE-ENGAGIERT, es sieht nie begeht, von anderen gleichzeitigen Transaktionen während dieser Zeit - wie Löscht.

Weiter zu deiner Frage : "was meinst du mit "mit der Transaktion isolation?" Ich bin mir nicht sicher, wie vertraut Sie mit Isolationsstufen, aber eine kurze übersicht kann hilfreich sein :

Transaction isolation levels wurden eingeführt zu verringern, blockieren und so maximieren Sie den Durchsatz von mehreren gleichzeitigen Datenbank-Transaktionen. Zum Beispiel, nehmen wir an, wir haben zwei verbindungen A und B, die im Idealfall möchten, führen Sie gemäß dem folgenden Zeitplan :

  • t=0: Vorgang A beginnt
  • t=1: Vorgang B beginnt
  • t=2: Transaktion A schreibt bis Zeile X (dauert so ein Write-Lock)
  • t=3: Transaktion B liest Zeile X (dauert so ein Read-lock)
  • t=4): eine Transaktion führt Eine andere liest/schreibt
  • t=5: Transaktion B führt andere liest/schreibt
  • t=6: Transaktion Ein commit
  • t=7: Transaktion B begeht

"Traditionell" (also wie SQL verwendet, um Verhalten, bevor die Transaktion isolation levels), Schritt, "t=3" konnte nicht nehmen Sie eine lese-Sperre auf etwas, dass eine andere Transaktion bereits eine write-Sperre auf. Das hätte bedeutet, dass Transaktion B blockiert, bis die Transaktion Ein commit bei t=6; Nur dann würde die lese-Sperre erteilt werden und die Transaktion könnte B starten Sie die Transaktion. dh, die Transaktionen ausführen, einen nach dem anderen, nacheinander (LANGSAM!).

Isolation Ebenen können sowohl Datenbank-Transaktionen gehen gleichzeitig. Die Wahl, welches isolation-level ausgewählt wurde, wäre festzustellen, ob B sieht der ursprüngliche Wert des row-X, oder der neue Wert, den Einer geschrieben hat ("dirty-read" - gefährlich, da Eine kann gut rollback der Transaktion, was bedeutet, dass B wäre Links halten, ein Wert, der nie "wirklich" existiert in der Datenbank).

Sie können sich also vorstellen, dass, wenn Ein ist Ihre Transaktion LÖSCHEN, und B ist Ihre Kafka-Prozess, dann READ COMMITTED bedeutet Kafka sehen würde, die ursprünglichen un-gelöschte Zeile.

+2
2019-09-17 10:31:06

Schritt 1.

Machen Sie Ihre struct Codable. Der compiler schreiben, die alle Funktionen für Sie, wenn alle Mitglieder Ihre struct sind Codable und glücklicherweise String ist Codable so sein, nur:

struct Object: Codable {
  var heading : String!
  var imageName: String!
}

Schritt 2.

Das problem mit "Codable " ist, dass es konvertiert in und aus Data, aber Sie möchten, konvertieren Sie zu und von einem Dictionary sein. Zum Glück JSONSerialization konvertiert von Data zu Dictionary so machen, ein neues Protokoll und geben Sie eine Standard-Implementierung mit Protokoll-Erweiterung:

protocol JSONRepresentable {
  init?(json: [String: Any])
  func json() -> [String: Any]
}
extension JSONRepresentable where Self: Codable {
  init?(json: [String:Any]) {
    guard let value = (try? JSONSerialization.data(withJSONObject: json, options: []))
      .flatMap ({ try? JSONDecoder().decode(Self.self, from: $0) }) else {
        return nil
    }
    self = value
  }
  func json() -> [String:Any] {
    return (try? JSONEncoder().encode(self))
      .flatMap { try? JSONSerialization.jsonObject(with: $0, options: []) } as? [String: Any] ?? [:]
  }
}

Schritt 3.

Entsprechen Ihre struct JSONRepresentable

struct Object: Codable, JSONRepresentable {
  var heading : String!
  var imageName: String!
}

Schritt 4.

Platzieren Sie Ihr Objekt in die Userdefaults und Holen Sie es wieder raus:

let o = Object.init(heading: "s", imageName: "a").json()
UserDefaults.standard.set(o, forKey: "test")
print(Object.init(json: UserDefaults.standard.dictionary(forKey: "test") ?? [:]))

Hier ist der ganze Spielplatz, wenn Sie möchten, es zu versuchen:

import UIKit

struct Object: Codable, JSONRepresentable {
  var heading : String!
  var imageName: String!
}

protocol JSONRepresentable {
  init?(json: [String: Any])
  func json() -> [String: Any]
}
extension JSONRepresentable where Self: Codable {
  init?(json: [String:Any]) {
    guard let value = (try? JSONSerialization.data(withJSONObject: json, options: []))
      .flatMap ({ try? JSONDecoder().decode(Self.self, from: $0) }) else {
        return nil
    }
    self = value
  }
  func json() -> [String:Any] {
    return (try? JSONEncoder().encode(self))
      .flatMap { try? JSONSerialization.jsonObject(with: $0, options: []) } as? [String: Any] ?? [:]
  }
}

let o = Object.init(heading: "s", imageName: "a").json()
UserDefaults.standard.set(o, forKey: "test")
print(Object.init(json: UserDefaults.standard.dictionary(forKey: "test") ?? [:]))
+2
2019-09-17 10:32:09

Check-out apscheduler für die Planung Ihrer Aufträge. Der code sieht wie folgt aus:

scheduler = BackgroundScheduler()
scheduler.add_job(check, 'cron', second='*/60')
scheduler.start()

# Function to run every 60 seconds
def check():
    pass
+0
2019-09-17 10:44:51

Sie müssen zunächst rufen Sie die Verbraucher-Methode verantwortlich für das senden der Benachrichtigung (Kanal) https://channels.readthedocs.io/en/latest/topics/channel_layers.html (Verwendung Außerhalb Von Verbrauchern)

import channels.layers
from asgiref.sync import async_to_sync

def SimpleShipping(data, **kwargs):

  group_name = 'notifications'
  channel_layer = channels.layers.get_channel_layer()

  async_to_sync(channel_layer.group_send)(
    group_name,
    {
      'type': 'notify_event',
      'data': data,
      # other: data,
    }
  )

deklarieren Sie die Methode im Verbraucher (Verbraucher hinzufügen, um die notification-Kanal)

import json

from asgiref.sync import async_to_sync
from channels.generic.websocket import WebsocketConsumer

class TournamentLobbyConsumer(WebsocketConsumer):

  room_group_name = 'notifications'

  def connect(self):
    # Join room group
    async_to_sync(self.channel_layer.group_add)(
      self.room_group_name,
      self.channel_name
    )

    self.accept()

  def disconnect(self, close_code):
    # Leave room group
    async_to_sync(self.channel_layer.group_discard)(
      self.room_group_name,
      self.channel_name
    )

  # Receive message from WebSocket
  def receive(self, text_data):
    # ...
    pass

  # Receive message from room group (notifications)
  def notify_event(self, event):
    data = event['data']
    # Send message to WebSocket
    self.send(text_data=json.dumps({
      'data': data,
    }))

nun müssen Sie die Methode auswählen, die für hintergrund-Aufgaben (Sellerie empfohlen http://docs.celeryproject.org/en/latest/django/first-steps-with-django.html) (Blick auf diese Frage Django Sellerie Periodischen Task zu einer bestimmten Zeit)


from projectname.appname.modulename import SimpleShipping

@shared_task()
def daily_reports():
  # Run the query in the database.
  # ...
  data = { 'results': 'results' }
  # notify consumers (results)
  SimpleShipping(data)

Anmerkung: ich hoffe es hilft, da die Aufgabe, die Sie umsetzen wollen, ist ziemlich umfangreich, und Sie sollten nicht auf die leichte Schulter, obwohl diese Zusammenfassung wird Ihnen erlauben, zu sehen, den Fluss von Daten

+0
2019-09-17 10:44:51

Sie können verwenden Sie GroupBy.Summe

sum_month=t2.groupby('a').sum()
print(sum_month)

      b  c  d
a            
feb   6  8  6
jan  11  9  5
mar   9 -3  8

wenn Sie es wünschen sortiert werden, genau wie in Ihrem Ausgang wartete dann verwenden Sie sort = False

sum_month=t2.groupby('a',sort=False).sum()
print(sum_month)

      b  c  d
a            
jan  11  9  5
feb   6  8  6
mar   9 -3  8
+1
2019-09-17 11:05:39

Geht aus der dataframe Probe, die Sie zur Verfügung gestellt, der folgende code funktioniert:

tf2.groupby('a').sum()
+1
2019-09-17 11:05:39

Wenn Sie möchten, um die Summe aller Spalten, dann brauchen Sie nur dieses:

import pandas as pd

a = {'a':['jan','feb','mar','jan','feb','mar'],'b':[1,5,0,10,1,9],'c':[2,3,-1,7,5,-2],'d':[1,-1,0,4,7,8]}
df = pd.DataFrame(a)

grouped_df = df.groupby('a').sum())
print(grouped_df)

Durch die übergabe .Summe() als Aggregatfunktion, es wird standardmäßig die Summe aller Spalten werden gruppiert, wenn Sie eine bestimmte Spalte oder ein array ist, dann wird das sum in der angegebenen. Ausgabe:

      b  c  d
a
feb   6  8  6
jan  11  9  5
mar   9 -3  8
+1
2019-09-17 11:05:39

Sehen Sie sich andere Fragen zu Tags an