Column hiding

Hide individual columns to reduce screen clutter and improve the grid’s performance.

Overview

“Hiding a column” means that the hidden column doesn’t get rendered as a DOM element.

When you’re hiding a column:

The source data doesn’t get modified.
The HiddenColumns plugin doesn’t participate in data transformation
(the shape of the data returned by the getData*() methods stays intact).

Enable column hiding

To enable column hiding, use the hiddenColumns option.

1
/* file: app.component.ts */
2
import { Component } from '@angular/core';
3
import { GridSettings } from '@handsontable/angular-wrapper';
4

5
@Component({
6
  selector: 'app-example1',
7
  template: `
8
    <hot-table
9
      [settings]="hotSettings!" [data]="hotData">
10
    </hot-table>
11
  `,
12
  standalone: false
13
})
14
export class AppComponent {
15

16
  readonly hotData = [
17
    ['A1', 'B1', 'C1', 'D1', 'E1', 'F1', 'G1', 'H1', 'I1', 'J1', 'K1', 'L1'],
18
    ['A2', 'B2', 'C2', 'D2', 'E2', 'F2', 'G2', 'H2', 'I2', 'J2', 'K2', 'L2'],
19
    ['A3', 'B3', 'C3', 'D3', 'E3', 'F3', 'G3', 'H3', 'I3', 'J3', 'K3', 'L3'],
20
    ['A4', 'B4', 'C4', 'D4', 'E4', 'F4', 'G4', 'H4', 'I4', 'J4', 'K4', 'L4'],
21
    ['A5', 'B5', 'C5', 'D5', 'E5', 'F5', 'G5', 'H5', 'I5', 'J5', 'K5', 'L5'],
22
  ];
23

24
  readonly hotSettings: GridSettings = {
25
    height: 'auto',
26
    colHeaders: true,
27
    rowHeaders: true,
28
    contextMenu: true,
29
    // enable the `HiddenColumns` plugin
30
    hiddenColumns: {
31
      columns: [2, 4, 6],
32
      indicators: true,
33
    },
34
    autoWrapRow: true,
35
    autoWrapCol: true,
36
  };
37
}
38
/* end-file */
39

40

41
/* file: app.module.ts */
42
import { NgModule, ApplicationConfig } from '@angular/core';
43
import { BrowserModule } from '@angular/platform-browser';
44
import { registerAllModules } from 'handsontable/registry';
45
import { HOT_GLOBAL_CONFIG, HotGlobalConfig, HotTableModule } from '@handsontable/angular-wrapper';
46
import { CommonModule } from '@angular/common';
47
import { NON_COMMERCIAL_LICENSE } from '@handsontable/angular-wrapper';
48

49
/* start:skip-in-compilation */
50
import { AppComponent } from './app.component';
51
/* end:skip-in-compilation */
52

53
// register Handsontable's modules
54
registerAllModules();
55

56
export const appConfig: ApplicationConfig = {
57
  providers: [
58
    {
59
      provide: HOT_GLOBAL_CONFIG,
60
      useValue: {
61
        license: NON_COMMERCIAL_LICENSE,
62
      } as HotGlobalConfig
63
    }
64
  ],
65
};
66

67
@NgModule({
68
  imports: [ BrowserModule, HotTableModule, CommonModule ],
69
  declarations: [ AppComponent ],
70
  providers: [...appConfig.providers],
71
  bootstrap: [ AppComponent ]
72
})
73

74
export class AppModule { }
75
/* end-file */

1
<div>
2
    <app-example1></app-example1>
3
</div>

Set up column hiding

To set up your column hiding configuration, follow the steps below.

Specify columns hidden by default

To both enable column hiding and specify columns hidden by default, set the hiddenColumns configuration option to an object.

In the object, add a columns configuration option, and set it to an array of column indexes.

Now, those columns are hidden by default:
TypeScript
```
1
/* file: app.component.ts */
2
import { Component } from '@angular/core';
3
import { GridSettings } from '@handsontable/angular-wrapper';
4

5
@Component({
6
  selector: 'app-example2',
7
  template: `
8
    <hot-table
9
      [settings]="hotSettings!" [data]="hotData">
10
    </hot-table>
11
  `,
12
  standalone: false
13
})
14
export class AppComponent {
15

16
  readonly hotData = [
17
    ['A1', 'B1', 'C1', 'D1', 'E1', 'F1', 'G1', 'H1', 'I1', 'J1', 'K1', 'L1'],
18
    ['A2', 'B2', 'C2', 'D2', 'E2', 'F2', 'G2', 'H2', 'I2', 'J2', 'K2', 'L2'],
19
    ['A3', 'B3', 'C3', 'D3', 'E3', 'F3', 'G3', 'H3', 'I3', 'J3', 'K3', 'L3'],
20
    ['A4', 'B4', 'C4', 'D4', 'E4', 'F4', 'G4', 'H4', 'I4', 'J4', 'K4', 'L4'],
21
    ['A5', 'B5', 'C5', 'D5', 'E5', 'F5', 'G5', 'H5', 'I5', 'J5', 'K5', 'L5'],
22
  ];
23

24
  readonly hotSettings: GridSettings = {
25
    height: 'auto',
26
    colHeaders: true,
27
    rowHeaders: true,
28
    // enable the `HiddenColumns` plugin
29
    hiddenColumns: {
30
      // specify columns hidden by default
31
      columns: [3, 5, 9],
32
    },
33
    autoWrapRow: true,
34
    autoWrapCol: true,
35
  };
36
}
37
/* end-file */
38

39

40
/* file: app.module.ts */
41
import { NgModule, ApplicationConfig } from '@angular/core';
42
import { BrowserModule } from '@angular/platform-browser';
43
import { registerAllModules } from 'handsontable/registry';
44
import { HOT_GLOBAL_CONFIG, HotGlobalConfig, HotTableModule } from '@handsontable/angular-wrapper';
45
import { CommonModule } from '@angular/common';
46
import { NON_COMMERCIAL_LICENSE } from '@handsontable/angular-wrapper';
47

48
/* start:skip-in-compilation */
49
import { AppComponent } from './app.component';
50
/* end:skip-in-compilation */
51

52
// register Handsontable's modules
53
registerAllModules();
54

55
export const appConfig: ApplicationConfig = {
56
  providers: [
57
    {
58
      provide: HOT_GLOBAL_CONFIG,
59
      useValue: {
60
        license: NON_COMMERCIAL_LICENSE,
61
      } as HotGlobalConfig
62
    }
63
  ],
64
};
65

66
@NgModule({
67
  imports: [ BrowserModule, HotTableModule, CommonModule ],
68
  declarations: [ AppComponent ],
69
  providers: [...appConfig.providers],
70
  bootstrap: [ AppComponent ]
71
})
72

73
export class AppModule { }
74
/* end-file */
```
HTML
```
1
<div>
2
  <app-example2></app-example2>
3
</div>
```
Show UI indicators

To easily see which columns are currently hidden, display UI indicators.

To enable the UI indicators, in the hiddenColumns object, set the indicators property to true:

If you use both the NestedHeaders plugin and the HiddenColumns plugin, you also need to set the colHeaders property to true. Otherwise, indicators won't work.
TypeScript
```
1
/* file: app.component.ts */
2
import { Component } from '@angular/core';
3
import { GridSettings } from '@handsontable/angular-wrapper';
4

5
@Component({
6
  selector: 'app-example3',
7
  template: `
8
    <hot-table
9
      [settings]="hotSettings!" [data]="hotData">
10
    </hot-table>
11
  `,
12
  standalone: false
13
})
14
export class AppComponent {
15

16
  readonly hotData = [
17
    ['A1', 'B1', 'C1', 'D1', 'E1', 'F1', 'G1', 'H1', 'I1', 'J1', 'K1', 'L1'],
18
    ['A2', 'B2', 'C2', 'D2', 'E2', 'F2', 'G2', 'H2', 'I2', 'J2', 'K2', 'L2'],
19
    ['A3', 'B3', 'C3', 'D3', 'E3', 'F3', 'G3', 'H3', 'I3', 'J3', 'K3', 'L3'],
20
    ['A4', 'B4', 'C4', 'D4', 'E4', 'F4', 'G4', 'H4', 'I4', 'J4', 'K4', 'L4'],
21
    ['A5', 'B5', 'C5', 'D5', 'E5', 'F5', 'G5', 'H5', 'I5', 'J5', 'K5', 'L5'],
22
  ];
23

24
  readonly hotSettings: GridSettings = {
25
    height: 'auto',
26
    colHeaders: true,
27
    rowHeaders: true,
28
    hiddenColumns: {
29
      columns: [3, 5, 9],
30
      // show UI indicators to mark hidden columns
31
      indicators: true,
32
    },
33
    autoWrapRow: true,
34
    autoWrapCol: true,
35
  };
36
}
37
/* end-file */
38

39

40
/* file: app.module.ts */
41
import { NgModule, ApplicationConfig } from '@angular/core';
42
import { BrowserModule } from '@angular/platform-browser';
43
import { registerAllModules } from 'handsontable/registry';
44
import { HOT_GLOBAL_CONFIG, HotGlobalConfig, HotTableModule } from '@handsontable/angular-wrapper';
45
import { CommonModule } from '@angular/common';
46
import { NON_COMMERCIAL_LICENSE } from '@handsontable/angular-wrapper';
47

48
/* start:skip-in-compilation */
49
import { AppComponent } from './app.component';
50
/* end:skip-in-compilation */
51

52
// register Handsontable's modules
53
registerAllModules();
54

55
export const appConfig: ApplicationConfig = {
56
  providers: [
57
    {
58
      provide: HOT_GLOBAL_CONFIG,
59
      useValue: {
60
        license: NON_COMMERCIAL_LICENSE,
61
      } as HotGlobalConfig
62
    }
63
  ],
64
};
65

66
@NgModule({
67
  imports: [ BrowserModule, HotTableModule, CommonModule ],
68
  declarations: [ AppComponent ],
69
  providers: [...appConfig.providers],
70
  bootstrap: [ AppComponent ]
71
})
72

73
export class AppModule { }
74
/* end-file */
```
HTML
```
1
<div>
2
  <app-example3></app-example3>
3
</div>
```
Set up context menu items

To easily hide and unhide columns, add column hiding items to Handsontable’s context menu.

Enable both the ContextMenu plugin and the HiddenColumns plugin. Now, the context menu automatically displays additional items for hiding and unhiding columns.
TypeScript
```
1
/* file: app.component.ts */
2
import { Component } from '@angular/core';
3
import { GridSettings } from '@handsontable/angular-wrapper';
4

5
@Component({
6
  selector: 'app-example4',
7
  template: `
8
    <hot-table
9
      [settings]="hotSettings!" [data]="hotData">
10
    </hot-table>
11
  `,
12
  standalone: false
13
})
14
export class AppComponent {
15

16
  readonly hotData = [
17
    ['A1', 'B1', 'C1', 'D1', 'E1', 'F1', 'G1', 'H1', 'I1', 'J1', 'K1', 'L1'],
18
    ['A2', 'B2', 'C2', 'D2', 'E2', 'F2', 'G2', 'H2', 'I2', 'J2', 'K2', 'L2'],
19
    ['A3', 'B3', 'C3', 'D3', 'E3', 'F3', 'G3', 'H3', 'I3', 'J3', 'K3', 'L3'],
20
    ['A4', 'B4', 'C4', 'D4', 'E4', 'F4', 'G4', 'H4', 'I4', 'J4', 'K4', 'L4'],
21
    ['A5', 'B5', 'C5', 'D5', 'E5', 'F5', 'G5', 'H5', 'I5', 'J5', 'K5', 'L5'],
22
  ];
23

24
  readonly hotSettings: GridSettings = {
25
    height: 'auto',
26
    colHeaders: true,
27
    rowHeaders: true,
28
    // enable the context menu
29
    contextMenu: true,
30
    // enable the `HiddenColumns` plugin
31
    // automatically adds the context menu's column hiding items
32
    hiddenColumns: {
33
      columns: [3, 5, 9],
34
      indicators: true,
35
    },
36
    autoWrapRow: true,
37
    autoWrapCol: true,
38
  };
39
}
40
/* end-file */
41

42

43
/* file: app.module.ts */
44
import { NgModule, ApplicationConfig } from '@angular/core';
45
import { BrowserModule } from '@angular/platform-browser';
46
import { registerAllModules } from 'handsontable/registry';
47
import { HOT_GLOBAL_CONFIG, HotGlobalConfig, HotTableModule } from '@handsontable/angular-wrapper';
48
import { CommonModule } from '@angular/common';
49
import { NON_COMMERCIAL_LICENSE } from '@handsontable/angular-wrapper';
50

51
/* start:skip-in-compilation */
52
import { AppComponent } from './app.component';
53
/* end:skip-in-compilation */
54

55
// register Handsontable's modules
56
registerAllModules();
57

58
export const appConfig: ApplicationConfig = {
59
  providers: [
60
    {
61
      provide: HOT_GLOBAL_CONFIG,
62
      useValue: {
63
        license: NON_COMMERCIAL_LICENSE,
64
      } as HotGlobalConfig
65
    }
66
  ],
67
};
68

69
@NgModule({
70
  imports: [ BrowserModule, HotTableModule, CommonModule ],
71
  declarations: [ AppComponent ],
72
  providers: [...appConfig.providers],
73
  bootstrap: [ AppComponent ]
74
})
75

76
export class AppModule { }
77
/* end-file */
```
HTML
```
1
<div>
2
  <app-example4></app-example4>
3
</div>
```
You can also add the column hiding menu items individually, by adding the hidden_columns_show and hidden_columns_hide strings to the contextMenu parameter:
TypeScript
```
1
/* file: app.component.ts */
2
import { Component } from '@angular/core';
3
import { GridSettings } from '@handsontable/angular-wrapper';
4

5
@Component({
6
  selector: 'app-example5',
7
  template: `
8
    <hot-table
9
      [settings]="hotSettings!" [data]="hotData">
10
    </hot-table>
11
  `,
12
  standalone: false
13
})
14
export class AppComponent {
15

16
  readonly hotData = [
17
    ['A1', 'B1', 'C1', 'D1', 'E1', 'F1', 'G1', 'H1', 'I1', 'J1', 'K1', 'L1'],
18
    ['A2', 'B2', 'C2', 'D2', 'E2', 'F2', 'G2', 'H2', 'I2', 'J2', 'K2', 'L2'],
19
    ['A3', 'B3', 'C3', 'D3', 'E3', 'F3', 'G3', 'H3', 'I3', 'J3', 'K3', 'L3'],
20
    ['A4', 'B4', 'C4', 'D4', 'E4', 'F4', 'G4', 'H4', 'I4', 'J4', 'K4', 'L4'],
21
    ['A5', 'B5', 'C5', 'D5', 'E5', 'F5', 'G5', 'H5', 'I5', 'J5', 'K5', 'L5'],
22
  ];
23

24
  readonly hotSettings: GridSettings = {
25
    height: 'auto',
26
    colHeaders: true,
27
    rowHeaders: true,
28
    // individually add column hiding context menu items
29
    contextMenu: ['hidden_columns_show', 'hidden_columns_hide'],
30
    hiddenColumns: {
31
      columns: [3, 5, 9],
32
      indicators: true,
33
    },
34
    autoWrapRow: true,
35
    autoWrapCol: true,
36
  };
37
}
38
/* end-file */
39

40

41
/* file: app.module.ts */
42
import { NgModule, ApplicationConfig } from '@angular/core';
43
import { BrowserModule } from '@angular/platform-browser';
44
import { registerAllModules } from 'handsontable/registry';
45
import { HOT_GLOBAL_CONFIG, HotGlobalConfig, HotTableModule } from '@handsontable/angular-wrapper';
46
import { CommonModule } from '@angular/common';
47
import { NON_COMMERCIAL_LICENSE } from '@handsontable/angular-wrapper';
48

49
/* start:skip-in-compilation */
50
import { AppComponent } from './app.component';
51
/* end:skip-in-compilation */
52

53
// register Handsontable's modules
54
registerAllModules();
55

56
export const appConfig: ApplicationConfig = {
57
  providers: [
58
    {
59
      provide: HOT_GLOBAL_CONFIG,
60
      useValue: {
61
        license: NON_COMMERCIAL_LICENSE,
62
      } as HotGlobalConfig
63
    }
64
  ],
65
};
66

67
@NgModule({
68
  imports: [ BrowserModule, HotTableModule, CommonModule ],
69
  declarations: [ AppComponent ],
70
  providers: [...appConfig.providers],
71
  bootstrap: [ AppComponent ]
72
})
73

74
export class AppModule { }
75
/* end-file */
```
HTML
```
1
<div>
2
  <app-example5></app-example5>
3
</div>
```
Set up copy and paste behavior

By default, hidden columns are included in copying and pasting.

To exclude hidden columns from copying and pasting, in the hiddenColumns object, set the copyPasteEnabled property to false:
TypeScript
```
1
/* file: app.component.ts */
2
import { Component } from '@angular/core';
3
import { GridSettings } from '@handsontable/angular-wrapper';
4

5
@Component({
6
  selector: 'app-example6',
7
  template: `
8
    <hot-table
9
      [settings]="hotSettings!" [data]="hotData">
10
    </hot-table>
11
  `,
12
  standalone: false
13
})
14
export class AppComponent {
15

16
  readonly hotData = [
17
    ['A1', 'B1', 'C1', 'D1', 'E1', 'F1', 'G1', 'H1', 'I1', 'J1', 'K1', 'L1'],
18
    ['A2', 'B2', 'C2', 'D2', 'E2', 'F2', 'G2', 'H2', 'I2', 'J2', 'K2', 'L2'],
19
    ['A3', 'B3', 'C3', 'D3', 'E3', 'F3', 'G3', 'H3', 'I3', 'J3', 'K3', 'L3'],
20
    ['A4', 'B4', 'C4', 'D4', 'E4', 'F4', 'G4', 'H4', 'I4', 'J4', 'K4', 'L4'],
21
    ['A5', 'B5', 'C5', 'D5', 'E5', 'F5', 'G5', 'H5', 'I5', 'J5', 'K5', 'L5'],
22
  ];
23

24
  readonly hotSettings: GridSettings = {
25
    height: 'auto',
26
    colHeaders: true,
27
    rowHeaders: true,
28
    contextMenu: ['hidden_columns_show', 'hidden_columns_hide'],
29
    hiddenColumns: {
30
      columns: [3, 5, 9],
31
      indicators: true,
32
      // exclude hidden columns from copying and pasting
33
      copyPasteEnabled: false,
34
    },
35
    autoWrapRow: true,
36
    autoWrapCol: true,
37
  };
38
}
39
/* end-file */
40

41

42
/* file: app.module.ts */
43
import { NgModule, ApplicationConfig } from '@angular/core';
44
import { BrowserModule } from '@angular/platform-browser';
45
import { registerAllModules } from 'handsontable/registry';
46
import { HOT_GLOBAL_CONFIG, HotGlobalConfig, HotTableModule } from '@handsontable/angular-wrapper';
47
import { CommonModule } from '@angular/common';
48
import { NON_COMMERCIAL_LICENSE } from '@handsontable/angular-wrapper';
49

50
/* start:skip-in-compilation */
51
import { AppComponent } from './app.component';
52
/* end:skip-in-compilation */
53

54
// register Handsontable's modules
55
registerAllModules();
56

57
export const appConfig: ApplicationConfig = {
58
  providers: [
59
    {
60
      provide: HOT_GLOBAL_CONFIG,
61
      useValue: {
62
        license: NON_COMMERCIAL_LICENSE,
63
      } as HotGlobalConfig
64
    }
65
  ],
66
};
67

68
@NgModule({
69
  imports: [ BrowserModule, HotTableModule, CommonModule ],
70
  declarations: [ AppComponent ],
71
  providers: [...appConfig.providers],
72
  bootstrap: [ AppComponent ]
73
})
74

75
export class AppModule { }
76
/* end-file */
```
HTML
```
1
<div>
2
    <app-example6></app-example6>
3
</div>
```

Column hiding API methods

For the most popular column hiding tasks, use the API methods below.

To see your changes, re-render your Handsontable instance with the render() method.

Access the `HiddenColumns` plugin instance

To access the HiddenColumns plugin instance, use the getPlugin() method:

1
const plugin = hot.getPlugin('hiddenColumns');

Hide a single column

To hide a single column, use the hideColumn() method:

1
const plugin = hot.getPlugin('hiddenColumns');
2

3
plugin.hideColumn(4);
4

5
// re-render your Handsontable instance
6
hot.render();

Hide multiple columns

To hide multiple columns:

Either pass column indexes as arguments to the hideColumn() method
Or pass an array of column indexes to the hideColumns() method

1
const plugin = hot.getPlugin('hiddenColumns');
2

3
plugin.hideColumn(0, 4, 6);
4
// or
5
plugin.hideColumns([0, 4, 6]);
6

7
// re-render your Handsontable instance
8
hot.render();

Unhide a single column

To unhide a single column, use the showColumn() method:

1
const plugin = hot.getPlugin('hiddenColumns');
2

3
plugin.showColumn(4);
4

5
// re-render your Handsontable instance
6
hot.render();

Unhide multiple columns

To unhide multiple columns:

Either pass column indexes as arguments to the showColumn() method
Or pass an array of column indexes to the showColumns() method

1
const plugin = hot.getPlugin('hiddenColumns');
2

3
plugin.showColumn(0, 4, 6);
4
// or
5
plugin.showColumns([0, 4, 6]);
6

7
// re-render your Handsontable instance
8
hot.render();