Beherskelse af asynkrone strømme: Sammensætning af streams med JavaScript Async Iterator Helper

I det konstant udviklende landskab for asynkron programmering fortsætter JavaScript med at introducere kraftfulde funktioner, der forenkler kompleks datahåndtering. En sådan innovation er Async Iterator Helper, en revolutionerende ændring for opbygning og sammensætning af robuste asynkrone datastrømme. Denne guide dykker dybt ned i verdenen af asynkrone iteratorer og demonstrerer, hvordan man udnytter Async Iterator Helper til elegant og effektiv streamsammensætning, hvilket giver udviklere over hele verden mulighed for at håndtere udfordrende databehandlingsscenarier med selvtillid.

Grundlaget: Forståelse af asynkrone iteratorer

Før vi dykker ned i streamsammensætning, er det afgørende at forstå det grundlæggende i asynkrone iteratorer i JavaScript. Asynkrone iteratorer er en naturlig udvidelse af iterator-protokollen, designet til at håndtere sekvenser af værdier, der ankommer asynkront over tid. De er særligt nyttige til operationer som:

• Læsning af data fra netværksanmodninger (f.eks. store fil-downloads, API-pagineringer).
• Behandling af data fra databaser eller filsystemer.
• Håndtering af realtidsdata-feeds (f.eks. WebSockets, Server-Sent Events).
• Håndtering af langvarige asynkrone opgaver, der producerer mellemliggende resultater.

En asynkron iterator er et objekt, der implementerer metoden [Symbol.asyncIterator](). Denne metode returnerer et asynkront iteratorobjekt, som igen har en next()-metode. next()-metoden returnerer et Promise, der resolver til et iteratorresultatobjekt, som indeholder egenskaberne value og done, ligesom almindelige iteratorer.

Her er et grundlæggende eksempel på en asynkron generatorfunktion, som giver en bekvem måde at oprette asynkrone iteratorer på:

            async function* asyncNumberGenerator(limit) {
  for (let i = 1; i <= limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 100)); // Simuler asynkron forsinkelse
    yield i;
  }
}

async function processAsyncStream() {
  const numbers = asyncNumberGenerator(5);
  for await (const num of numbers) {
    console.log(num);
  }
}

processAsyncStream();
// Output:
// 1
// 2
// 3
// 4
// 5

            

              
                Copy
              
            
          

for await...of-løkken er den idiomatiske måde at forbruge asynkrone iteratorer på, da den abstraherer den manuelle kald af next() og håndteringen af Promises. Dette får asynkron iteration til at føles meget mere synkron og læsbar.

Introduktion til Async Iterator Helper

Selvom asynkrone iteratorer er kraftfulde, kan det blive omstændeligt og repetitivt at sammensætte dem til komplekse datapipelines. Det er her, Async Iterator Helper (ofte tilgået via hjælpebiblioteker eller eksperimentelle sprogfunktioner) kommer til sin ret. Den tilbyder et sæt metoder til at transformere, kombinere og manipulere asynkrone iteratorer, hvilket muliggør deklarativ og sammensættelig streambehandling.

Tænk på det som array-metoderne (map, filter, reduce) for synkrone iterables, men specifikt designet til den asynkrone verden. Async Iterator Helper sigter mod at:

• Forenkle almindelige asynkrone operationer.
• Fremme genbrugelighed gennem funktionel sammensætning.
• Forbedre læsbarheden og vedligeholdelsen af asynkron kode.
• Forbedre ydeevnen ved at levere optimerede stream-transformationer.

Mens den native implementering af en omfattende Async Iterator Helper stadig er under udvikling i JavaScript-standarderne, tilbyder mange biblioteker fremragende implementeringer. Til formålet med denne guide vil vi diskutere koncepter og demonstrere mønstre, der er bredt anvendelige og ofte afspejles i populære biblioteker som:

• `ixjs` (Interactive JavaScript): Et omfattende bibliotek for reaktiv programmering og streambehandling.
• `rxjs` (Reactive Extensions for JavaScript): Et vidt udbredt bibliotek for reaktiv programmering med Observables, som ofte kan konverteres til/fra asynkrone iteratorer.
• Brugerdefinerede hjælpefunktioner: At bygge dine egne sammensættelige hjælpere.

Vi vil fokusere på de mønstre og muligheder, som en robust Async Iterator Helper tilbyder, frem for et specifikt biblioteks API, for at sikre en globalt relevant og fremtidssikret forståelse.

Kerne-teknikker til streamsammensætning

Streamsammensætning involverer at kæde operationer sammen for at transformere en kilde-asynkron iterator til et ønsket output. Async Iterator Helper tilbyder typisk metoder til:

1. Mapping: Transformering af hver værdi

map-operationen anvender en transformationsfunktion på hvert element, der udsendes af den asynkrone iterator. Dette er essentielt for at konvertere dataformater, udføre beregninger eller berige eksisterende data.

Koncept:

sourceIterator.map(transformFunction)

Hvor transformFunction(value) returnerer den transformerede værdi (som også kan være et Promise for yderligere asynkron transformation).

Eksempel: Lad os tage vores asynkrone talgenerator og mappe hvert tal til dets kvadrat.

            async function* asyncNumberGenerator(limit) {
  for (let i = 1; i <= limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

// Forestil dig en 'map'-funktion, der virker med asynkrone iteratorer
async function* mapAsyncIterator(asyncIterator, transformFn) {
  for await (const value of asyncIterator) {
    yield await Promise.resolve(transformFn(value));
  }
}

async function processMappedStream() {
  const numbers = asyncNumberGenerator(5);
  const squaredNumbers = mapAsyncIterator(numbers, num => num * num);

  console.log("Kvadrerede tal:");
  for await (const squaredNum of squaredNumbers) {
    console.log(squaredNum);
  }
}

processMappedStream();
// Output:
// Kvadrerede tal:
// 1
// 4
// 9
// 16
// 25

            

              
                Copy
              
            
          

Global relevans: Dette er fundamentalt for internationalisering. For eksempel kan du mappe tal til formaterede valutastrenge baseret på en brugers lokalitet, eller transformere tidsstempler fra UTC til en lokal tidszone.

2. Filtrering: Valg af specifikke værdier

filter-operationen giver dig mulighed for kun at beholde de elementer, der opfylder en given betingelse. Dette er afgørende for datarensning, valg af relevant information eller implementering af forretningslogik.

Koncept:

sourceIterator.filter(predicateFunction)

Hvor predicateFunction(value) returnerer true for at beholde elementet eller false for at kassere det. Prædikatet kan også være asynkront.

Eksempel: Filtrer vores tal for kun at inkludere de lige.

            async function* asyncNumberGenerator(limit) {
  for (let i = 1; i <= limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

// Forestil dig en 'filter'-funktion for asynkrone iteratorer
async function* filterAsyncIterator(asyncIterator, predicateFn) {
  for await (const value of asyncIterator) {
    if (await Promise.resolve(predicateFn(value))) {
      yield value;
    }
  }
}

async function processFilteredStream() {
  const numbers = asyncNumberGenerator(10);
  const evenNumbers = filterAsyncIterator(numbers, num => num % 2 === 0);

  console.log("Lige tal:");
  for await (const evenNum of evenNumbers) {
    console.log(evenNum);
  }
}

processFilteredStream();
// Output:
// Lige tal:
// 2
// 4
// 6
// 8
// 10

            

              
                Copy
              
            
          

Global relevans: Filtrering er afgørende for håndtering af forskelligartede datasæt. Forestil dig at filtrere brugerdata for kun at inkludere dem fra specifikke lande eller regioner, eller at filtrere produktlister baseret på tilgængelighed på en brugers nuværende marked.

3. Reducering: Aggregering af værdier

reduce-operationen konsoliderer alle værdier fra en asynkron iterator til et enkelt resultat. Dette bruges almindeligvis til at summere tal, sammenkæde strenge eller bygge komplekse objekter.

Koncept:

sourceIterator.reduce(reducerFunction, initialValue)

Hvor reducerFunction(accumulator, currentValue) returnerer den opdaterede akkumulator. Både reduceren og akkumulatoren kan være asynkrone.

Eksempel: Summer alle tal fra vores generator.

            async function* asyncNumberGenerator(limit) {
  for (let i = 1; i <= limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

// Forestil dig en 'reduce'-funktion for asynkrone iteratorer
async function reduceAsyncIterator(asyncIterator, reducerFn, initialValue) {
  let accumulator = initialValue;
  for await (const value of asyncIterator) {
    accumulator = await Promise.resolve(reducerFn(accumulator, value));
  }
  return accumulator;
}

async function processReducedStream() {
  const numbers = asyncNumberGenerator(5);
  const sum = await reduceAsyncIterator(numbers, (acc, num) => acc + num, 0);

  console.log(`Sum af tal: ${sum}`);
}

processReducedStream();
// Output:
// Sum af tal: 15

            

              
                Copy
              
            
          

Global relevans: Aggregering er nøglen til analyse og rapportering. Du kan reducere salgsdata til et samlet omsætningstal, eller aggregere brugerfeedback-scores på tværs af forskellige regioner.

4. Kombination af iteratorer: Fletning og sammenkædning

Ofte vil du have brug for at behandle data fra flere kilder. Async Iterator Helper tilbyder metoder til at kombinere iteratorer effektivt.

• concat(): Tilføjer en eller flere asynkrone iteratorer til en anden og behandler dem sekventielt.
• merge(): Kombinerer flere asynkrone iteratorer og udsender værdier, efterhånden som de bliver tilgængelige fra en hvilken som helst af kilderne (samtidigt).

Eksempel: Sammenkædning af streams

            async function* generatorA() {
  yield 'A1'; await new Promise(r => setTimeout(r, 50));
  yield 'A2';
}

async function* generatorB() {
  yield 'B1';
  yield 'B2'; await new Promise(r => setTimeout(r, 50));
}

// Forestil dig en 'concat'-funktion
async function* concatAsyncIterators(...iterators) {
  for (const iterator of iterators) {
    for await (const value of iterator) {
      yield value;
    }
  }
}

async function processConcatenatedStream() {
  const streamA = generatorA();
  const streamB = generatorB();
  const concatenatedStream = concatAsyncIterators(streamA, streamB);

  console.log("Sammenkædet stream:");
  for await (const item of concatenatedStream) {
    console.log(item);
  }
}

processConcatenatedStream();
// Output:
// Sammenkædet stream:
// A1
// A2
// B1
// B2

            

              
                Copy
              
            
          

Eksempel: Fletning af streams

            async function* streamWithDelay(id, delay, count) {
  for (let i = 0; i < count; i++) {
    await new Promise(resolve => setTimeout(resolve, delay));
    yield `${id}:${i}`;
  }
}

// Forestil dig en 'merge'-funktion (mere kompleks at implementere effektivt)
async function* mergeAsyncIterators(...iterators) {
  const iteratorsState = iterators.map(it => ({ iterator: it[Symbol.asyncIterator](), nextPromise: null }));
  
  // Initialiser første next promises
  iteratorsState.forEach(state => {
    state.nextPromise = state.iterator.next().then(result => ({ ...result, index: iteratorsState.indexOf(state) }));
  });

  let pending = iteratorsState.length;
  while (pending > 0) {
    const winner = await Promise.race(iteratorsState.map(state => state.nextPromise));

    if (!winner.done) {
      yield winner.value;
      // Hent næste fra den vindende iterator
      iteratorsState[winner.index].nextPromise = iteratorsState[winner.index].iterator.next().then(result => ({ ...result, index: winner.index }));
    } else {
      // Iterator er færdig, fjern den fra ventende
      pending--;
      iteratorsState[winner.index].nextPromise = Promise.resolve({ done: true, index: winner.index }); // Markér som færdig
    }
  }
}

async function processMergedStream() {
  const stream1 = streamWithDelay('S1', 200, 3);
  const stream2 = streamWithDelay('S2', 150, 4);

  const mergedStream = mergeAsyncIterators(stream1, stream2);

  console.log("Flettet stream:");
  for await (const item of mergedStream) {
    console.log(item);
  }
}

processMergedStream();
/* Eksempel på output (rækkefølgen kan variere lidt på grund af timing):
Flettet stream:
S2:0
S1:0
S2:1
S1:1
S2:2
S1:2
S2:3
*/

            

              
                Copy
              
            
          

Global relevans: Fletning er uvurderlig til behandling af data fra distribuerede systemer eller realtidskilder. For eksempel at flette aktiekursopdateringer fra forskellige børser eller kombinere sensoraflæsninger fra geografisk spredte enheder.

5. Batching og opdeling i bidder (chunking)

Nogle gange har du brug for at behandle data i grupper i stedet for individuelt. Batching indsamler et specificeret antal elementer, før de udsendes som et array.

Koncept:

sourceIterator.batch(batchSize)

Eksempel: Saml tal i batches af 3.

            async function* asyncNumberGenerator(limit) {
  for (let i = 1; i <= limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

// Forestil dig en 'batch'-funktion
async function* batchAsyncIterator(asyncIterator, batchSize) {
  let batch = [];
  for await (const value of asyncIterator) {
    batch.push(value);
    if (batch.length === batchSize) {
      yield batch;
      batch = [];
    }
  }
  if (batch.length > 0) { // Udsend eventuelle resterende elementer
    yield batch;
  }
}

async function processBatchedStream() {
  const numbers = asyncNumberGenerator(7);
  const batchedNumbers = batchAsyncIterator(numbers, 3);

  console.log("Batchede tal:");
  for await (const batch of batchedNumbers) {
    console.log(batch);
  }
}

processBatchedStream();
// Output:
// Batchede tal:
// [ 1, 2, 3 ]
// [ 4, 5, 6 ]
// [ 7 ]

            

              
                Copy
              
            
          

Global relevans: Batching er afgørende for effektive I/O-operationer, især når man håndterer API'er med rate limits eller begrænsninger på anmodningsstørrelse. For eksempel kan afsendelse af data til en analysetjeneste i batches markant reducere antallet af API-kald og forbedre ydeevnen.

6. Debouncing og Throttling

Disse teknikker er vitale for at styre den hastighed, hvormed asynkrone hændelser behandles, for at forhindre overbelastning af downstream-systemer eller brugergrænsefladen.

• Debouncing: Forsinker udførelse, indtil en vis periode med inaktivitet er gået. Nyttigt til handlinger som automatisk lagring eller søgeforslag.
• Throttling: Sikrer, at en funktion kaldes højst én gang inden for et specificeret tidsinterval. Nyttigt til håndtering af hyppige hændelser som scrolling eller vinduesændring.

Eksempel: Debouncing af søgeinput

Forestil dig en asynkron iterator, der udsender brugerens søgeforespørgsler, mens de skrives. Vi ønsker kun at udløse et API-kald til søgning, efter at brugeren er stoppet med at skrive i en kort periode.

            // Pladsholder for en debouncing-funktion for asynkrone iteratorer
// Dette ville typisk involvere timere og tilstandshåndtering.
// For simpelhedens skyld vil vi beskrive adfærden.

async function* debounceAsyncIterator(asyncIterator, delayMs) {
  let lastValue;
  let timeoutId;
  let isWaiting = false;

  for await (const value of asyncIterator) {
    lastValue = value;
    if (timeoutId) {
      clearTimeout(timeoutId);
    }
    if (!isWaiting) {
      isWaiting = true;
      timeoutId = setTimeout(async () => {
        yield lastValue;
        isWaiting = false;
      }, delayMs);
    }
  }

  // Hvis der er en afventende værdi, efter løkken er færdig
  if (isWaiting && lastValue !== undefined) {
    yield lastValue;
  }
}

// Simuler en strøm af søgeforespørgsler
async function* simulateSearchQueries() {
  yield 'jav';
  await new Promise(r => setTimeout(r, 100));
  yield 'java';
  await new Promise(r => setTimeout(r, 100));
  yield 'javas';
  await new Promise(r => setTimeout(r, 500)); // Pause
  yield 'javasc';
  await new Promise(r => setTimeout(r, 300)); // Pause
  yield 'javascript';
}

async function processDebouncedStream() {
  const queries = simulateSearchQueries();
  const debouncedQueries = debounceAsyncIterator(queries, 400); // Vent 400ms efter sidste input

  console.log("Debounced søgeforespørgsler:");
  for await (const query of debouncedQueries) {
    console.log(`Udløser søgning efter: "${query}"`);
    // I en rigtig app ville dette kalde et API.
  }
}

processDebouncedStream();
/* Eksempel på output:
Debounced søgeforespørgsler:
Udløser søgning efter: "javascript"
*/

            

              
                Copy
              
            
          

Global relevans: Debouncing og throttling er afgørende for at bygge responsive og højtydende brugergrænseflader på tværs af forskellige enheder og netværksforhold. Implementering af disse på klientsiden eller serversiden sikrer en glat brugeroplevelse globalt.

Opbygning af komplekse pipelines

Den sande styrke ved streamsammensætning ligger i at kæde disse operationer sammen for at danne komplekse databehandlingspipelines. Async Iterator Helper gør dette deklarativt og læsbart.

Scenarie: Hentning af paginerede brugerdata, filtrering for aktive brugere, mapning af deres navne til store bogstaver og derefter batching af resultaterne til visning.

            // Antag, at disse er asynkrone iteratorer, der returnerer brugerobjekter { id: number, name: string, isActive: boolean }

async function* fetchPaginatedUsers(page) {
  console.log(`Henter side ${page}...`);
  await new Promise(resolve => setTimeout(resolve, 300));
  // Simuler data for forskellige sider
  if (page === 1) {
    yield { id: 1, name: 'Alice', isActive: true };
    yield { id: 2, name: 'Bob', isActive: false };
    yield { id: 3, name: 'Charlie', isActive: true };
  } else if (page === 2) {
    yield { id: 4, name: 'David', isActive: true };
    yield { id: 5, name: 'Eve', isActive: false };
    yield { id: 6, name: 'Frank', isActive: true };
  }
}

// Funktion til at hente næste side med brugere
async function getNextPageOfUsers(currentPage) {
  // I et virkeligt scenarie ville dette tjekke, om der er mere data
  if (currentPage < 2) {
    return fetchPaginatedUsers(currentPage + 1);
  }
  return null; // Ikke flere sider
}

// Simuler en 'flatMap' eller 'concatMap'-lignende adfærd for pagineret hentning
async function* flatMapAsyncIterator(asyncIterator, mapFn) {
  for await (const value of asyncIterator) {
    const mappedIterator = mapFn(value);
    for await (const innerValue of mappedIterator) {
      yield innerValue;
    }
  }
}

async function complexStreamPipeline() {
  // Start med den første side
  let currentPage = 0;
  const initialUserStream = fetchPaginatedUsers(currentPage + 1);

  // Kæde af operationer:
  const processedStream = initialUserStream
    .pipe(
      // Tilføj paginering: hvis en bruger er den sidste på en side, hent næste side
      flatMapAsyncIterator(async (user, stream) => {
        const results = [user];
        // Denne del er en forenkling. Rigtig pagineringslogik kan kræve mere kontekst.
        // Lad os antage, at vores fetchPaginatedUsers yielder 3 elementer, og vi vil hente næste, hvis tilgængelig.
        // En mere robust tilgang ville være at have en kilde, der selv ved, hvordan man paginerer.
        return results;
      }),
      filterAsyncIterator(user => user.isActive),
      mapAsyncIterator(user => ({ ...user, name: user.name.toUpperCase() })),
      batchAsyncIterator(2) // Batch i grupper af 2
    );

  console.log("Resultater fra kompleks pipeline:");
  for await (const batch of processedStream) {
    console.log(batch);
  }
}

// Dette eksempel er konceptuelt. Faktisk implementering af flatMap/pagineringskædning
// ville kræve mere avanceret tilstandshåndtering i stream-hjælperne.
// Lad os forfine tilgangen for et klarere eksempel.

// En mere realistisk tilgang til håndtering af paginering ved hjælp af en brugerdefineret kilde
async function* paginatedUserSource(totalPages) {
  for (let page = 1; page <= totalPages; page++) {
    yield* fetchPaginatedUsers(page);
  }
}

async function sophisticatedStreamComposition() {
  const userSource = paginatedUserSource(2); // Hent fra 2 sider

  const pipeline = userSource
    .pipe(
      filterAsyncIterator(user => user.isActive),
      mapAsyncIterator(user => ({ ...user, name: user.name.toUpperCase() })),
      batchAsyncIterator(2)
    );

  console.log("Resultater fra sofistikeret pipeline:");
  for await (const batch of pipeline) {
    console.log(batch);
  }
}

sophisticatedStreamComposition();
/* Eksempel på output:
Resultater fra sofistikeret pipeline:
[ { id: 1, name: 'ALICE', isActive: true }, { id: 3, name: 'CHARLIE', isActive: true } ]
[ { id: 4, name: 'DAVID', isActive: true }, { id: 6, name: 'FRANK', isActive: true } ]
*/

            

              
                Copy
              
            
          

Dette demonstrerer, hvordan du kan kæde operationer sammen og skabe et læsbart og vedligeholdeligt databehandlingsflow. Hver operation tager en asynkron iterator og returnerer en ny, hvilket muliggør en flydende API-stil (ofte opnået ved hjælp af en pipe-metode).

Ydeevneovervejelser og bedste praksis

Selvom streamsammensætning tilbyder enorme fordele, er det vigtigt at være opmærksom på ydeevne:

• Lazy evaluering: Asynkrone iteratorer er i sagens natur "lazy". Operationer udføres kun, når der anmodes om en værdi. Dette er generelt godt, men vær opmærksom på den kumulative overhead, hvis du har mange kortlivede mellemliggende iteratorer.
• Backpressure: I systemer med producenter og forbrugere med varierende hastigheder er backpressure afgørende. Hvis en forbruger er langsommere end en producent, kan producenten sænke farten eller pause for at undgå at opbruge hukommelsen. Biblioteker, der implementerer async iterator helpers, har ofte mekanismer til at håndtere dette implicit eller eksplicit.
• Asynkrone operationer inden for transformationer: Når dine map- eller filter-funktioner involverer deres egne asynkrone operationer, skal du sikre dig, at de håndteres korrekt. Brug af Promise.resolve() eller async/await i disse funktioner er nøglen.
• Valg af det rigtige værktøj: Til meget kompleks realtidsdatabehandling kan biblioteker som RxJS med Observables tilbyde mere avancerede funktioner (f.eks. sofistikeret fejlhåndtering, annullering). Men til mange almindelige scenarier er Async Iterator Helper-mønstre tilstrækkelige og kan være mere på linje med native JavaScript-konstruktioner.
• Test: Test dine sammensatte streams grundigt, især i kanttilfælde som tomme streams, streams med fejl og streams, der afsluttes uventet.

Globale anvendelser af asynkron streamsammensætning

Principperne for asynkron streamsammensætning er universelt anvendelige:

• E-handelsplatforme: Behandling af produktfeeds fra flere leverandører, filtrering efter region eller tilgængelighed og aggregering af lagerdata.
• Finansielle tjenester: Realtidsbehandling af markedsdatastrømme, aggregering af transaktionslogfiler og udførelse af svindelregistrering.
• Internet of Things (IoT): Indtagelse og behandling af data fra millioner af sensorer verden over, filtrering af relevante begivenheder og udløsning af alarmer.
• Content Management Systems: Asynkron hentning og transformation af indhold fra forskellige kilder, personalisering af brugeroplevelser baseret på deres placering eller præferencer.
• Big Data-behandling: Håndtering af store datasæt, der ikke passer i hukommelsen, og behandling af dem i bidder eller streams til analyse.

Konklusion

JavaScripts Async Iterator Helper, enten gennem native funktioner eller robuste biblioteker, tilbyder et elegant og kraftfuldt paradigme til at bygge og sammensætte asynkrone datastrømme. Ved at omfavne teknikker som mapping, filtrering, reducering og kombination af iteratorer kan udviklere skabe sofistikerede, læsbare og højtydende databehandlingspipelines.

Evnen til at kæde operationer deklarativt sammen forenkler ikke kun kompleks asynkron logik, men fremmer også genbrugelighed og vedligeholdelse af kode. Efterhånden som JavaScript fortsætter med at modnes, vil beherskelse af asynkron streamsammensætning være en stadig mere værdifuld færdighed for enhver udvikler, der arbejder med asynkrone data, og give dem mulighed for at bygge mere robuste, skalerbare og effektive applikationer for et globalt publikum.

Begynd at udforske mulighederne, eksperimenter med forskellige sammensætningsmønstre, og frigør det fulde potentiale af asynkrone datastrømme i dit næste projekt!