Übersetzung für "Iterieren über" in Englisch
																						Warum
																											beeinflusst
																											die
																											Reihenfolge
																											der
																											Schleifen
																											die
																											Leistung
																											beim
																											Iterieren
																											über
																											ein
																											2D-Array?
																		
			
				
																						Why
																											does
																											the
																											order
																											of
																											the
																											loops
																											affect
																											performance
																											when
																											iterating
																											over
																											a
																											2D
																											array?
															 
				
		 CCAligned v1
			
																						Wir
																											iterieren
																											nur
																											über
																											die
																											inneren
																											Parzellen.
																		
			
				
																						We
																											iterate
																											only
																											over
																											the
																											inner
																											parcels.
															 
				
		 ParaCrawl v7.1
			
																						Im
																											letzten
																											Schritt
																											iterieren
																											wir
																											über
																											die
																											gefundenen
																											Marker,
																											um
																											ihre
																											Transformationsmatrizen
																											zu
																											erhalten.
																		
			
				
																						The
																											last
																											step
																											is
																											to
																											iterate
																											through
																											the
																											detected
																											markers
																											and
																											get
																											their
																											transformation
																											matrices.
															 
				
		 ParaCrawl v7.1
			
																						Beim
																											Iterieren
																											über
																											Container
																											mit
																											Hilfe
																											eines
																											Makros
																											dürfen
																											innerhalb
																											dieses
																											Makros
																											die
																											Schleifensprung-Anweisungen
																											break
																											und
																											continue
																											wie
																											gewohnt
																											benutzen
																											werden.
																		
			
				
																						When
																											iterating
																											over
																											containers
																											with
																											the
																											help
																											of
																											a
																											macro,
																											the
																											loop
																											skip
																											statements
																											break
																											and
																											continue
																											may
																											be
																											used
																											within
																											this
																											macro
																											as
																											usual.
															 
				
		 ParaCrawl v7.1
			
																						Die
																											Makros,
																											die
																											zum
																											Iterieren
																											über
																											die
																											zu
																											einem
																											Knoten
																											(im
																											Sinne
																											von
																											LEDA)
																											adjazenten
																											Kanten
																											und
																											Knoten
																											dienen,
																											arbeiten
																											anders
																											als
																											bei
																											einem
																											gerichteten
																											graph.
																		
			
				
																						The
																											macros
																											that
																											serve
																											to
																											iterate
																											over
																											the
																											edges
																											and
																											nodes
																											that
																											are
																											adjacent
																											to
																											a
																											node
																											(in
																											the
																											sense
																											of
																											LEDA)
																											work
																											differently
																											from
																											with
																											a
																											directed
																											graph.
															 
				
		 ParaCrawl v7.1
			
																						Anstatt
																											also
																											z.B.
																											über
																											die
																											Sequenz
																											von
																											Product
																											Nodes
																											im
																											Beispiel
																											in
																											der
																											Abbildung
																											oben
																											zu
																											iterieren,
																											können
																											wir
																											über
																											einen
																											Zahlenbereich
																											iterieren,
																											der
																											mit
																											der
																											Node-Sequenz
																											verknüpft
																											ist.
																		
			
				
																						For
																											example,
																											instead
																											of
																											iterating
																											over
																											the
																											sequence
																											of
																											Product
																											nodes
																											in
																											the
																											screenshot
																											example
																											above,
																											we
																											can
																											iterate
																											over
																											a
																											range
																											of
																											numbers
																											that
																											is
																											tied
																											to
																											the
																											node
																											sequence.
															 
				
		 ParaCrawl v7.1
			
																						Mit
																											Hilfe
																											rekursiver
																											benutzerdefinierter
																											Funktionen
																											können
																											Sie
																											verschiedene
																											komplexe
																											Mapping-Aufgaben
																											lösen,
																											wie
																											z.B.
																											das
																											Iterieren
																											über
																											Datenstrukturen
																											mit
																											einer
																											Tiefe
																											von
																											N
																											Children,
																											wobei
																											N
																											im
																											Vorhinein
																											nicht
																											bekannt
																											ist,
																											siehe
																											Beispiel:
																											Rekursive
																											Suche
																											.
																		
			
				
																						Recursive
																											user-defined
																											functions
																											let
																											you
																											solve
																											various
																											advanced
																											mapping
																											requirements,
																											such
																											as
																											iterating
																											over
																											data
																											structures
																											having
																											a
																											depth
																											of
																											N
																											children,
																											where
																											N
																											is
																											not
																											known
																											in
																											advance,
																											see
																											Example:
																											Recursive
																											Search
																											.
															 
				
		 ParaCrawl v7.1
			
																						Anschließend
																											iterieren
																											wir
																											über
																											die
																											zuvor
																											definierten
																											Features
																											und
																											schreiben
																											das
																											jeweilige
																											Feature
																											in
																											unser
																											li-Element
																											(4),
																											klonen
																											das
																											Ganze
																											(5)
																											und
																											fügen
																											den
																											Klon
																											in
																											die
																											Liste
																											ein
																											(6)
																		
			
				
																						Then
																											we
																											iterate
																											over
																											the
																											previously
																											defined
																											features
																											and
																											write
																											the
																											respective
																											feature
																											into
																											our
																											li
																											element
																											(4),
																											clone
																											the
																											whole
																											thing
																											(5)
																											and
																											insert
																											the
																											clone
																											into
																											the
																											list
																											(6).
															 
				
		 ParaCrawl v7.1
			
																						Iterieren
																											Sie
																											über
																											die
																											Knoten
																											erst
																											in
																											ihrer
																											natürlichen
																											Reihenfolge
																											in
																											V,
																											dann
																											in
																											einer
																											zufälligen
																											Reihenfolge.
																		
			
				
																						First
																											iterate
																											over
																											the
																											nodes
																											in
																											their
																											natural
																											order
																											in
																											V,
																											then
																											in
																											a
																											random
																											order.
															 
				
		 ParaCrawl v7.1
			
																						Das
																											bedeutet,
																											wir
																											müssen
																											nur
																											einmal
																											über
																											die
																											Datei
																											iterieren
																											und
																											dann
																											über
																											die
																											Satzzeichen
																											iterieren
																											-
																											eine
																											viel
																											kleinere
																											Liste.
																		
			
				
																						This
																											means
																											we
																											only
																											need
																											to
																											interate
																											over
																											the
																											file
																											once
																											and
																											then
																											iterate
																											over
																											the
																											punctuation
																											-
																											a
																											much
																											smaller
																											list.
															 
				
		 ParaCrawl v7.1
			
																						Dann
																											iterieren
																											wir
																											über
																											alle
																											Elemente
																											in
																											der
																											personList
																											und
																											führen
																											unterschiedliche
																											Aktionen
																											durch,
																											je
																											nachdem,
																											um
																											welchen
																											spezifischen
																											Subtyp
																											von
																											Person
																											es
																											sich
																											handelt
																											(unter
																											Verwendung
																											eines
																											Vererbungssplits).
																		
			
				
																						Then
																											we
																											iterate
																											over
																											all
																											the
																											items
																											in
																											the
																											personList
																											and
																											take
																											a
																											different
																											action
																											based
																											on
																											what
																											specific
																											subtype
																											of
																											Person
																											the
																											item
																											is
																											(using
																											an
																											inheritance
																											split).
															 
				
		 ParaCrawl v7.1
			
																						Die
																											Vision,
																											an
																											der
																											wir
																											arbeiten,
																											ist
																											die
																											eines
																											Application
																											Servers
																											–
																											allerdings
																											einer,
																											der
																											in
																											einem
																											wichtigen
																											Aspekt
																											anders
																											ist,
																											als
																											die
																											anderen:
																											Anstatt
																											dem
																											Anwendungsentwickler
																											sämtliche
																											Freiheiten
																											zu
																											geben
																											(iterieren
																											über
																											eine
																											Liste
																											von
																											Dokumenten
																											IDs,
																											Abfragen
																											auf
																											Basis
																											der
																											IDs
																											durchführen
																											und
																											auf
																											Basis
																											der
																											Ergebnisse
																											weitere
																											abhängige
																											Abfragen
																											durchführen),
																											definieren
																											wir
																											„sichere
																											Transformationen”,
																											so
																											wie
																											view,
																											show,
																											list
																											und
																											update.
																		
			
				
																						The
																											bigger
																											picture
																											we’re
																											working
																											on
																											is
																											like
																											an
																											app
																											server,
																											but
																											different
																											in
																											one
																											crucial
																											regard:
																											rather
																											than
																											let
																											the
																											developer
																											do
																											whatever
																											he
																											wants
																											(loop
																											a
																											list
																											of
																											DocIDs
																											and
																											make
																											queries,
																											make
																											queries
																											based
																											on
																											the
																											results
																											of
																											other
																											queries,
																											etc.),
																											we’re
																											defining
																											“safe”
																											transformations,
																											such
																											as
																											view,
																											show,
																											list,
																											and
																											update.
															 
				
		 ParaCrawl v7.1
			
																						Sie
																											können
																											jedoch
																											auch
																											die
																											Sequenz,
																											über
																											die
																											iteriert
																											wird,
																											folgendermaßen
																											ändern:
																											Anstatt
																											direkt
																											über
																											die
																											Nodes
																											zu
																											iterieren,
																											wird
																											über
																											eine
																											Zahlensequenz
																											iteriert,
																											die
																											mit
																											der
																											Node-Sequenz
																											verknüpft
																											ist.
																		
			
				
																						You
																											can
																											also
																											modify
																											the
																											sequence
																											being
																											iterated
																											over
																											as
																											follows:
																											Instead
																											of
																											iterating
																											directly
																											over
																											the
																											nodes,
																											iterate
																											over
																											a
																											number
																											sequence
																											that
																											is
																											tied
																											to
																											the
																											node
																											sequence.
															 
				
		 ParaCrawl v7.1
			
																						Die
																											Vision,
																											an
																											der
																											wir
																											arbeiten,
																											ist
																											die
																											eines
																											Application
																											Servers
																											–
																											allerdings
																											einer,
																											der
																											in
																											einem
																											wichtigen
																											Aspekt
																											anders
																											ist,
																											als
																											die
																											anderen:
																											Anstatt
																											dem
																											Anwendungsentwickler
																											sämtliche
																											Freiheiten
																											zu
																											geben
																											(iterieren
																											über
																											eine
																											Liste
																											von
																											Dokumenten
																											IDs,
																											Abfragen
																											auf
																											Basis
																											der
																											IDs
																											durchführen
																											und
																											auf
																											Basis
																											der
																											Ergebnisse
																											weitere
																											abhängige
																											Abfragen
																											durchführen),
																											definieren
																											wir
																											"sichere
																											Transformationen",
																											so
																											wie
																											view,
																											show,
																											list
																											und
																											update.
																		
			
				
																						The
																											bigger
																											picture
																											we're
																											working
																											on
																											is
																											like
																											an
																											app
																											server,
																											but
																											different
																											in
																											one
																											crucial
																											regard:
																											rather
																											than
																											let
																											the
																											developer
																											do
																											whatever
																											he
																											wants
																											(loop
																											a
																											list
																											of
																											DocIDs
																											and
																											make
																											queries,
																											make
																											queries
																											based
																											on
																											the
																											results
																											of
																											other
																											queries,
																											etc.),
																											we're
																											defining
																											"safe"
																											transformations,
																											such
																											as
																											view,
																											show,
																											list,
																											and
																											update.
															 
				
		 ParaCrawl v7.1
			
																						Wie
																											iteriere
																											ich
																											über
																											ein
																											Enum?
																		
			
				
																						How
																											do
																											I
																											iterate
																											over
																											an
																											enum?
															 
				
		 CCAligned v1
			
																						Wie
																											iteriere
																											ich
																											über
																											ein
																											NSArray?
																		
			
				
																						How
																											do
																											I
																											iterate
																											over
																											an
																											NSArray?
															 
				
		 CCAligned v1
			
																						Iteriere
																											über
																											alle
																											Klassen,
																											die
																											in
																											der
																											Eingabemenge
																											sind
																											(das
																											angegebene
																											Fileset).
																		
			
				
																						Iterate
																											over
																											all
																											classes,
																											which
																											are
																											in
																											the
																											input
																											quantity
																											(the
																											indicated
																											file
																											set).
															 
				
		 ParaCrawl v7.1