Geschwindigkeit

Es scheint mehrere Lösungen für das Problem zu geben. Ich würde ein paar ausprobieren und ggf die schnellste wählen.

...somit dürfte der ganze Rest - die Diskussion über enthaltenes RegEx (oder auch nicht) - total egal sein, solange die Funktion am Ende auch funktioniert, richtig?

Zitat von autoBert

Oder hast du den Source des AutoItinterpreters?

Zitat von chip

Logische Schlussfolgerung.

Hättest du dann, wie Ineluki, den Code gelesen, wüsstest du, das kein RegEx benutzt wird.

Zitat von minx

Hättest du dann, wie Ineluki, den Code gelesen, wüsstest du, das kein RegEx benutzt wird.

Im Gegensatz zu dir kleiner Mann sage ich ja nix dagegen das ich mich geirrt habe (wobei das nach wir vor nicht bewiesen ist wie es im aktuellen Code ist bzw. es absoluter Blödsinn ist nicht bereits vorhanden C Methoden zu verwenden). War nur zur Vollständigkeit bezüglich Split-Regexp und .net Framework.

Ich hatte wenigstens zugegeben, dass ich mich gerirrt habe, bis Ineluki den Code gezeigt hat. Du allerdings gehst ja nichtmal darauf ein. Zukünftig recherchierst du vielleicht mal, bevor du mir einen "Bildungsausftrag an der Jugend" machen willst.

Der Code ist sicherlich kein "absoluter Blödsinn". Und das: "War nur zur Vollständigkeit bezüglich Split-Regexp und .net Framework." ist ziemlich falsch, da, wie wir schon erörtert haben, du noch nichtmal weist ob das überhaupt benutzt wird.

Im Changelog steht nichts von Änderungen an der StringSplit Funktion, also bleibt das klar Fazit:

StringSplit arbeitet auch intern sehr wahrscheinlich nicht mit RegExp.

Nur darum geht es, und du brauchst da nicht sagen, du hättest nicht das Gegenteil behauptet (ich hatte mir sogar die Mühe gemacht, mich in allen Beiträgen zu korrigieren, aber ich finde das Quellcode überzeugender als deine "Argumente". Denn du hast behauptet, du hast den Code. Hast ihn aber nicht gelesen.

Denn als großer Mann gibt man auch zu, dass man sich gerirrt hat. Und das, was ich von dir zitiert habe, hat nichts mit der Vollständigkeit zu tun.

Da wir jetzt alle wissen wie es funktioniert, könen wir denke ich mal einen Schlussstrich ziehen.

Zitat von minx

Der Code ist sicherlich kein "absoluter Blödsinn". Und das: "War nur zur Vollständigkeit bezüglich Split-Regexp und .net Framework." ist ziemlich falsch, da, wie wir schon erörtert haben, du noch nichtmal weist ob das überhaupt benutzt wird.

Ich merke schon mit lesen hast es nicht so wirklich ;). Das war die Antwort auf die indirekte Aussage von Autobert bezüglich Split-Regexp wäre nur mit .net 4.5 möglich.

Zitat von minx

Denn du hast behauptet, du hast den Code.

Wo?

Zitat von minx

Definitiv verwendet StringSplit() keine Regulären Ausdrücke.

Aber kleiner Mann auf deinen Beweis das in der aktuellen Autoitversion kein Regexp benutzt wird warte ich nach wie vor vergeblich.

https://autoit.de/index.php?page…5092#post275092

, was noch nicht einmal unrealistisch ist, da der COde ja eingesehen werden kann.

Aber da ich weiß, dass du sowie stur wie sonstwas bist, will ich da nicht weiter disktuieren, du hast behauptet es arbeitet mit RegEx, es it nicht so, jetzt wissen alle Bescheid. Damit ist alles geklärt.

Schon die Tatsache, dass du nichtmal auf meinen Beitrag wirklich eingehst, und nicht mal etwas einräumen kannst, lässt mich wirklich auf dich schließen. Für mich ist hier Ende. "Mit lesen hast du es nicht so wirklich", du wohl auch nicht, da es zwischen dir und mir nur um die Verwendung von RegEx und nichts anderem geht. Ich muss schon sagen, dass du bis jetzt der unfreundlichste Mensch hier im Forum gegenüber mir bist, und das muss ich mir nicht gefallen lassen. Ich kenne solche Leute leider auch im Reallife.

Ende Gelände, (gedankliches) Ignor wieder an, Schluss mit dem Rumgenerve.

Zitat von AnnaM

Diese Zeilen können sich also beliebig verändern wie schon beschrieben und in der nächsten steht der Betrag.
Also mache ich es lieber mit RegExp, oder? Ich will ja auch zu jeder Zeile den entsprechenden Preis haben.

gerade weil sie sich beliebig ändern können solltest du StringSplit nehmen:

Zitat von autoBert

Bei der StringSplit-Methode brauchtr man sich um nichts kümmern, wenn ein neuer Begriff auftaucht wird diese Zeile trotzdem autmatisch getrennt.
Bei der RegEx-Methode muss man das Skript anpassen und dies dauert länger als einige Millisekunden, vor allem muss man daran denken ansonsten werden Zeilen unterschlagen.

auch wenn durch eine 0 mehr es jetzt vielleicht Sekunden sind Skript anpassen dauert länger.

Zitat von chip

Ich merke schon mit lesen hast es nicht so wirklich ;). Das war die Antwort auf die indirekte Aussage von Autobert bezüglich Split-Regexp wäre nur mit .net 4.5 möglich.

Leider habe ich in diesem Beitrag nur bis

Zitat von chip

Logische Schlussfolgerung

gescrollt und sah mich bestätigt: du hast dich getäuscht.
Im übrigen hast du zu stark verkürzt zitiert:

Zitat von autoBert

Ich habe aber kein .NET Framework 4.5 installiert und bisher auch nirgends gelesen dass AutoIt überhaupt irgendein .NET Framework benötigt.

Dass du dann mit einem Link auf die MSDN:

Zitat von chip

Leg ich dir halt mal den Arm aus der Sonne: http://msdn.microsoft.com/de-de/library/…=vs.110%29.aspx

dass AutoIt StringSplit mit RegEx realisiert hat ist listig und daher

Zitat von chip

Und nun bist du dran minx, beweise mal das nicht Regexp benutzt.

nicht zulässig. Dies

Zitat von Ineluki

Ich denke mal das hier sollte die Diskussion klären:

Spoiler anzeigen

Code

AUT_RESULT AutoIt_Script::F_StringSplit(VectorVariant &vParams, Variant &vResult)
{
	int			iCount, iElements, iIndex;
	int			nPos, nFlag;
	char const	*pcSearch, *pcDelim, *pcTmp;	// pointer can change, but the pointed at stuff will not.
	Variant		*pvTemp;


	// For speed, pre-allocate our string class to be same size as input string
	AString		sElement((int)strlen(vParams[0].szValue()));


	if (vParams.size() < 3)
		nFlag = 0;
	else
		nFlag = vParams[2].nValue();


	pcSearch	= vParams[0].szValue();
	pcDelim		= vParams[1].szValue();


	// Create array with single characters when the delimiter is empty
	if (pcDelim[0] == '\0')
	{
		iCount   = 0;
		iIndex   = 1;
		iElements = (int)strlen(pcSearch);
		Util_VariantArrayDim(&vResult, iElements+1);    // create the array , String length + 1
		pvTemp = Util_VariantArrayGetRef(&vResult, 0);  // First element set to length
		*pvTemp = iElements;
		while (iCount < iElements)
		{
			sElement.assign(pcSearch, iCount, iCount + 1);
			pvTemp = Util_VariantArrayGetRef(&vResult, iIndex++);   //Next element
			*pvTemp = sElement.c_str();
			++iCount;                  // Increase count
		}
		return AUT_OK;
	}




	switch (nFlag)
	{
	case 0:	// default method - any characters in delimeter string delimit fields
		// Count how many times the delimiters occur
		iCount = 0;
		nPos = 0;
		while (pcSearch[nPos] != '\0')
		{
			if ( strchr(pcDelim, pcSearch[nPos]) )
					++iCount;						// Increase count
			++nPos;
		}
		break;
	case 1: // use exact delimeter string to delimit fields
		iCount=0;
		while (pcSearch != NULL)
		{
			pcSearch = strstr(pcSearch, pcDelim);
			if (pcSearch != NULL) {
				++iCount;
				pcSearch += strlen(pcDelim);	// skip by the length of the delimter
			}
		}
		// reset back to starting place
		pcSearch = vParams[0].szValue();
		break;
	default:
		iCount = -1;
	}


	// Find any delimiters?
	if (iCount <= 0)
	{
		// Create array of 2 to return count = 1 and full string in element[1]
		Util_VariantArrayDim(&vResult, 2);
		pvTemp = Util_VariantArrayGetRef(&vResult, 0);	//First element
		*pvTemp = 1;


		pvTemp = Util_VariantArrayGetRef(&vResult, 1);	//Second element
		*pvTemp = pcSearch;


		SetFuncErrorCode(-iCount+1);	// 1 for no delimiters, 2 for bad flag
		return AUT_OK;
	}




	// Number of string elements will be iCount number of delimiters + 1 (3 delims = 4 elements to return)
	iElements = iCount+1;


	// Create our return array (first element is number of strings return, so we need iElements+1 elements)
	Util_VariantArrayDim(&vResult, iElements+1);


	pvTemp = Util_VariantArrayGetRef(&vResult, 0);	//First element
	*pvTemp = iElements;							// Number of elements we will return




	// Go through the loop again but this time, make a note of the strings and store in our new array
	iCount	= 0;
	nPos	= 0;
	iIndex	= 1;
	sElement = "";
	bool bStored;
	while (iCount < iElements)
	{
		switch (nFlag)
		{
		case 0:
			bStored = false;
			if ( strchr(pcDelim, pcSearch[nPos]) )	// This works as \0 is also matched so overrun is prevented
			{
				pvTemp = Util_VariantArrayGetRef(&vResult, iIndex++);	//Next element
				*pvTemp = sElement.c_str();
				sElement = "";


				bStored = true;
				++iCount;						// Increase count
			}


			if (bStored == false)
				sElement += pcSearch[nPos];


			++nPos;
			break;
		case 1:
			pcTmp = pcSearch;
			pcSearch = strstr(pcSearch, pcDelim);
			if (pcSearch != NULL) {
				sElement = "";


				// copy all elements up to the beginning of the delimiter into sElement
				for (;pcTmp != pcSearch; ++pcTmp)
					sElement += *pcTmp;


				pcSearch += strlen(pcDelim);	// skip by the length of the delimter
			}
			else
				sElement = pcTmp;
			// copy string into array
			pvTemp = Util_VariantArrayGetRef(&vResult, iIndex++);	//Next element
			*pvTemp = sElement.c_str();
			++iCount;
			break;
		}	// switch
	}	// while (iCount < iElements)


	return AUT_OK;


}

Alles anzeigen

Ich persönlich sehe das kein RegEx.
Ist zwar von der 3.1.0 aber ich denke, da hat sich nichts geändert:
http://www.autoitscript.com/autoit3/files/…-v3.1.0-src.exe

sollte als Beweis genügen, ansonsten wäre es wohl im ChangeLog erwähnt.

mfg autoBert