O evento de mudança é chamado somente depois que o foco da entrada foi alterado. Como posso fazer com que o evento seja acionado a cada pressionamento de tecla?

<input type="text" [(ngModel)]="mymodel" (change)="valuechange($event)" />
{{mymodel}}

A segunda ligação é alterada a cada pressionamento de tecla.

Acabei de usar a entrada do evento e funcionou bem da seguinte maneira:

no arquivo .html:

<input type="text" class="form-control" (input)="onSearchChange($event.target.value)">

no arquivo .ts:

onSearchChange(searchValue: string): void {  
  console.log(searchValue);
}

Use ngModelChangedividindo a [(x)]sintaxe em suas duas partes, ou seja, ligação de dados de propriedades e ligação de eventos:

<input type="text" [ngModel]="mymodel" (ngModelChange)="valuechange($event)" />
{{mymodel}}

valuechange(newValue) {
  mymodel = newValue;
  console.log(newValue)
}

Também funciona para a tecla backspace.

O evento (keyup) é sua melhor aposta.

Vamos ver o porquê:

1. (alterar), como você mencionou, é acionado apenas quando a entrada perde o foco, portanto, é de uso limitado.
2. (pressionamento de tecla) é acionado ao pressionar as teclas, mas não é acionado em determinadas teclas, como no backspace.
3. (keydown) é acionado toda vez que uma tecla é pressionada. Portanto, sempre fica 1 caractere; pois obtém o estado do elemento antes do registro da tecla.
4. (keyup) é sua melhor aposta, pois é acionada toda vez que um evento de pressionamento de tecla é concluído, portanto, isso inclui também o caractere mais recente.

Então (keyup) é o mais seguro, porque ele ...

• registra um evento em cada pressionamento de tecla, ao contrário do evento (alteração)
• inclui as teclas que (pressionamento de tecla) ignora
• não tem atraso ao contrário do evento (keydown)

<input type="text" [ngModel]="mymodel" (keypress)="mymodel=$event.target.value"/>
{{mymodel}}

Uma maneira diferente de lidar com esses casos é usar o formControl e se inscrever valueChangesquando o componente for inicializado, o que permitirá que você use operadores rxjs para requisitos avançados, como a solicitação de http, aplique um debounce até que o usuário termine de escrever uma frase, use o último valor e omitir anterior, ...

import {Component, OnInit} from '@angular/core';
import { FormControl } from '@angular/forms';
import { debounceTime, distinctUntilChanged } from 'rxjs/operators';

@Component({
  selector: 'some-selector',
  template: `
    <input type="text" [formControl]="searchControl" placeholder="search">
  `
})
export class SomeComponent implements OnInit {
  private searchControl: FormControl;
  private debounce: number = 400;

  ngOnInit() {
    this.searchControl = new FormControl('');
    this.searchControl.valueChanges
      .pipe(debounceTime(this.debounce), distinctUntilChanged())
      .subscribe(query => {
        console.log(query);
      });
  }
}

O evento secreto que mantém ngModel angular sincronizado é a entrada da chamada de evento . Portanto, a melhor resposta para sua pergunta deve ser:

<input type="text" [(ngModel)]="mymodel" (input)="valuechange($event)" />
{{mymodel}}

<input type="text" (keypress)="myMethod(myInput.value)" #myInput />

arquivo .ts

myMethod(value:string){
...
...
}

O que você está procurando é

<input type="text" [(ngModel)]="mymodel" (keyup)="valuechange()" />
{{mymodel}}

Em seguida, faça o que quiser com os dados acessando o limite this.mymodelno seu arquivo .ts.

No meu caso, a solução é:

[ngModel]="X?.Y" (ngModelChange)="X.Y=$event"

Para formulários reativos, você pode assinar as alterações feitas em todos os campos ou apenas em um campo específico.

Obtenha todas as alterações de um FormGroup:

this.orderForm.valueChanges.subscribe(value => {
    console.dir(value);
});

Obtenha a alteração de um campo específico:

this.orderForm.get('orderPriority').valueChanges.subscribe(value => {
    console.log(value);
  });

Eu tenho usado keyup em um campo numérico, mas hoje notei no chrome que a entrada possui botões para cima / para baixo para aumentar / diminuir o valor que não é reconhecido pelo keyup.

Minha solução é usar o keyup e alterar juntos:

(keyup)="unitsChanged[i] = true" (change)="unitsChanged[i] = true"

Os testes iniciais indicam que isso funciona bem; serão postados de volta se houver algum erro encontrado após testes adicionais.