Das Schreiben und Testen von Funktionen kann sich anfühlen, als würden Sie in einem Hamsterrad laufen – Sie machen weiter, scheinen aber nirgendwo anzukommen. Es ist keine Schande; Jeder Entwickler kennt diesen Kampf. Aber was wäre, wenn wir Ihnen sagen würden, dass es jetzt eine Möglichkeit gibt, den gesamten Prozess zu optimieren? Testen von Code, Unit-Entwicklung und Unit-Tests sind normalerweise das, woran wir uns wenden, um sicherzustellen, dass unsere Funktion wie beabsichtigt funktioniert. Aber was wäre, wenn es einen noch besseren Weg gäbe, dies zu tun?

Das nächste Wort, das Ihnen in den Sinn kommt, ist höchstwahrscheinlich GPT-4 von OpenAI , die neueste Version der GPT-Serie. Kann ich meine Arbeit an GPT-4 auslagern und wird es eine gut aussehende, aber blind kaputte Implementierung liefern? Es scheint einen Weg zu geben, um sicherzustellen, dass Sie dies auch dann sofort erkennen und beheben können, wenn es kaputt ist (ja, sofort ).

Der Schlüssel ist, nichts selbst zu testen, sondern GPT-4 zu bitten, seine eigenen Testfälle und Testcodes zu schreiben und KI-Mikrotests einzuführen . Alles, was Sie dann tun müssen, ist mit dem Auge zu validieren, ob ALLE Anwendungs-/Testfälle enthalten sind und sinnvolle Ergebnisse liefern. So können Sie mit GPT-4 Funktionen in jeder Programmiersprache erstellen und testen. Lassen Sie uns für unser Beispiel JavaScript ausführen.

Erstellen einer CompareUrls-Funktion

Der Kürze halber dachte ich daran, eine Funktion in JavaScript zu schreiben, die zwei URLs mit Abfrageparametern vergleicht. Hier ist, was ich GPT-4 dazu aufgefordert habe:

Create a function in JavaScript that takes two URLs with query parameters and returns true if they are the same, otherwise false.

function compareUrls(url1, url2) {
  const searchParams1 = new URLSearchParams(url1.split('?')[1]);
  const searchParams2 = new URLSearchParams(url2.split('?')[1]);
  
  if (searchParams1.toString() !== searchParams2.toString()) {
    return false;
  }
  
  const baseURL1 = url1.split('?')[0];
  const baseURL2 = url2.split('?')[0];
  
  if (baseURL1 !== baseURL2) {
    return false;
  }
  
  return true;
}

Testen Sie Ihre Funktion

Nachdem Sie den von GPT-4 generierten Code erhalten haben, können Sie Ihre Funktion manuell testen, um sicherzustellen, dass sie korrekt ist, oder Sie können GPT-4 auffordern, einige (hoffentlich alle) Testfälle mit der folgenden Aufforderung zu erstellen:

Write all possible test cases as simple function calls.

compareUrls(
    'https://example.com/page?param1=foo',
    'https://example.com/page?param1=foo'
); // Returns true

compareUrls(
    'https://example.com/page?param1=foo',
    'https://example.com/page?param1=bar'
); // Returns false

compareUrls(
    'https://example.com/page?param1=foo&param2=bar',
    'https://example.com/page?param1=foo&param2=bar'
); // Returns true

compareUrls(
    'https://example.com/page?param1=foo&param2=bar',
    'https://example.com/page?param1=foo&param2=baz'
); // Returns false

compareUrls(
    'https://example.com/page?param1=foo&param2=bar',
    'https://example.com/different_page?param1=foo&param2=bar'
); // Returns false

compareUrls(
    'https://example.com/page?param1=foo&param2=bar&a=b',
    'https://example.com/page?a=b&param1=foo&param2=bar'
); // Returns true

console.log(
  compareUrls(
    'https://example.com/page?param1=foo',
    'https://example.com/page?param1=foo'
  ) === true
)

Enclose these in an array and iterate through them to check that every function call returns the expected value.
const testCases = [
  ['https://example.com/page?param1=foo', 'https://example.com/page?param1=foo', true],
  ['https://example.com/page?param1=foo', 'https://example.com/page?param1=bar', false],
  ['https://example.com/page?param1=foo&param2=bar', 'https://example.com/page?param1=foo&param2=bar', true],
  ['https://example.com/page?param1=foo&param2=bar', 'https://example.com/page?param1=foo&param2=baz', false],
  ['https://example.com/page?param1=foo&param2=bar', 'https://example.com/different_page?param1=foo&param2=bar', false],
  ['https://example.com/page?param1=foo&param2=bar&a=b', 'https://example.com/page?a=b&param1=foo&param2=bar', true]
];

const results = testCases.map(testCase => compareUrls(testCase[0], testCase[1]) === testCase[2]);

const allAreTrue = results.every(result => result === true);

console.log(allAreTrue, results);

1. Der Vergleich einer URL mit Parametern mit einer URL ohne Parameter funktioniert nicht korrekt, und
2. Der letzte Anwendungsfall gibt false zurück, da dies nicht vom ursprünglichen Funktionsentwurf behandelt wird.

What if you compare a url which does not have query parameters with another that does? Also, the last use case is returning false, so that is not being handled correctly by the code apparently. The urls should be considered equal, regardless of the order of params, as long as they have the same value. Can you fix it?

Endgültige CompareUrls-Implementierung und KI-Mikrotests

function compareUrls(url1, url2) {
  const searchParams1 = new URLSearchParams(url1.split('?')[1]);
  const searchParams2 = new URLSearchParams(url2.split('?')[1]);
  
  const allKeys = new Set([...searchParams1.keys(), ...searchParams2.keys()]);
  
  for (const key of allKeys) {
    const values1 = searchParams1.getAll(key).join(',');
    const values2 = searchParams2.getAll(key).join(',');
    
    if (values1 !== values2) {
      return false;
    }
  }
  
  const baseURL1 = url1.split('?')[0];
  const baseURL2 = url2.split('?')[0];
  
  if (baseURL1 !== baseURL2) {
    return false;
  }
  
  return true;
}

const testCases = [
  ['https://example.com/page', 'https://example.com/page', true],
  ['https://example.com/page', 'https://example.com/page?param1=foo', false],
  ['https://example.com/page?param1=foo', 'https://example.com/page?param1=foo', true],
  ['https://example.com/page?param1=foo', 'https://example.com/page?param1=bar', false],
  ['https://example.com/page?param1=foo&param2=bar', 'https://example.com/page?param1=foo&param2=bar', true],
  ['https://example.com/page?param1=foo&param2=bar', 'https://example.com/page?param1=foo&param2=baz', false],
  ['https://example.com/page?param1=foo&param2=bar', 'https://example.com/different_page?param1=foo&param2=bar', false],
  ['https://example.com/page?param1=foo&param2=bar&a=b', 'https://example.com/page?a=b&param2=bar&param1=foo', true],
  ['https://example.com/page?param1=foo&param2=bar', 'https://example.com/page?param2=bar&param1=foo', true]
];

const results = testCases.map(testCase => compareUrls(testCase[0], testCase[1]) === testCase[2]);

const allAreTrue = results.every(result => result === true);

console.log(allAreTrue, results);

Die Verwendung von GPT-4 zum Erstellen und Testen Ihrer Funktionen hat einige Vorteile:

1. Schnellere Implementierung: GPT-4 generiert den Code für Sie, wodurch der Implementierungsprozess schneller und effizienter wird.
2. Bessere Codequalität: GPT-4 bietet eine umfassende Testabdeckung, die bei entsprechender Aufforderung zu einer stabileren und gut getesteten Codebasis führt.
3. Spart Zeit: Entwickler können GPT-4 nutzen, um Zeit beim Erstellen von Testfällen zu sparen und sich auf andere Aspekte des Entwicklungsprozesses zu konzentrieren. GPT-4 schützt Sie vor ersten fehlerhaften Entwürfen, die normalerweise die meiste Zeit in Anspruch nehmen, um die Entwicklung in Gang zu bringen.
4. Iterative Verbesserung: Die Feedback-Schleife mit GPT-4 ermöglicht es Ihnen, Ihren Code und Ihre Testfälle iterativ zu verbessern, indem Sie Ihre Eingabeaufforderungen verfeinern.

Wenn Sie mit Software arbeiten, wissen Sie, wie wichtig es ist, sicherzustellen, dass alles richtig gemacht wird. Hier kommen Unit-Entwicklung und Unit-Tests ins Spiel. Es ist jedoch ein Schmerz, und selbst wenn Sie alles richtig machen, kann immer noch etwas durch die Ritzen rutschen. GPT-4 von OpenAI kann Ihr Leben einfacher machen – aber nicht ohne Probleme. Können wir einer Maschine vertrauen? Ist es besser als menschliches Versagen? Nicht immer.

Sehen Sie, GPT-4 ist nützlich, daran besteht kein Zweifel. Es kann Ihnen helfen, Funktionen besser und effizienter zu erstellen und zu testen. Es ist wie ein Koffeinschub für Ihre Prozesse. Keine Notwendigkeit, es zu beschönigen. Aber es ist nicht perfekt, und ohne ein scharfes Auge könnte es die Dinge sogar noch schlimmer machen.

Es liegt also an Ihnen, ob Sie GPT-4 eine Chance geben oder nicht. Aber wenn Sie das tun, werden Sie vielleicht feststellen, dass es Ihre Softwareentwicklung genauer und effizienter machen kann. Vergessen Sie nur nicht, dass jeder Silberstreifen mit einer Wolke einhergeht, und in der Technik bedeutet jeder Schritt nach vorne mehr Probleme, auf die Sie achten müssen. Stellen Sie also sicher, dass alle Testfälle enthalten sind, und validieren Sie sie selbst, bevor Sie sie an die Produktion senden!