## Note

tonal-note is a collection of functions to manipulate musical notes in scientific notation

This is part of tonal music theory library.

Usage

import * as Note from "tonal-note"
// or const Note = require("tonal-note")
Note.name("bb2") // => "Bb2"
Note.chroma("bb2") // => 10
Note.midi("a4") // => 69
Note.freq("a4") // => 440
Note.oct("G3") // => 3

// part of tonal
const Tonal = require("tonal")
// or import Note from "tonal"
Tonal.Note.midi("d4") // => 62

Install

API Documentation

* [Note](#module_Note) * _static_ * [.midi](#module_Note.midi) ⇒ Number * [.freqToMidi](#module_Note.freqToMidi) ⇒ Integer * [.from](#module_Note.from) * [.simplify](#module_Note.simplify) ⇒ string * [.props()](#module_Note.props) ⇒ string * [.name()](#module_Note.name) ⇒ string * [.midiToFreq(note)](#module_Note.midiToFreq) ⇒ Number * [.chroma(note)](#module_Note.chroma) ⇒ Integer * [.altToAcc(props, [baseNote])](#module_Note.altToAcc) ⇒ string * [.build(midi, useSharps)](#module_Note.build) ⇒ string * _inner_ * [~props](#module_Note..props) ⇒ Object * [~names(accTypes)](#module_Note..names) ⇒ Array * [~tokenize(str)](#module_Note..tokenize) ⇒ Array * [~midi(note)](#module_Note..midi) ⇒ Integer * [~freqToMidi(frequency)](#module_Note..freqToMidi) ⇒ Number * [~stepToLetter(step)](#module_Note..stepToLetter) ⇒ string * [~altToAcc(alt)](#module_Note..altToAcc) ⇒ string * [~simplify(note, useSameAccType)](#module_Note..simplify) ⇒ string ### Note.midi ⇒ Number

Get the frequency from midi number

**Kind**: static property of [Note](#module_Note) **Returns**: Number -

the frequency or null if not valid note midi

| Param | Type | Description | | --- | --- | --- | | midi | Number |

the note midi number

| | tuning | Number |

(Optional) 440 by default

| ### Note.freqToMidi ⇒ Integer

Return the chroma of a note. The chroma is the numeric equivalent to the pitch class, where 0 is C, 1 is C# or Db, 2 is D... 11 is B

**Kind**: static property of [Note](#module_Note) **Returns**: Integer -

the chroma number

| Param | Type | Description | | --- | --- | --- | | note | string |

the note name

| **Example** ```js Note.chroma("Cb") // => 11 ["C", "D", "E", "F"].map(Note.chroma) // => [0, 2, 4, 5] ``` ### Note.from

Deprecated. This is kept for backwards compatibility only. Use Note.from instead

**Kind**: static property of [Note](#module_Note) ### Note.simplify ⇒ string

Get the simplified and enhramonic note of the given one.

**Kind**: static property of [Note](#module_Note) **Returns**: string -

the enhramonic note

| Param | Type | | --- | --- | | note | string | **Example** ```js Note.enharmonic("Db") // => "C#" Note.enhramonic("C") // => "C" ``` ### Note.props() ⇒ string

Given a note name, return the note name or null if not valid note. The note name will ALWAYS have the letter in upercase and accidentals using # or b

Can be used to test if a string is a valid note name.

**Kind**: static method of [Note](#module_Note) | Param | Type | | --- | --- | | | Pitch \| string | **Example** ```js Note.name("cb2") // => "Cb2" ["c", "db3", "2", "g+", "gx4"].map(Note.name) // => ["C", "Db3", null, null, "G##4"] ``` ### Note.name() ⇒ string

Get pitch class of a note. The note can be a string or a pitch array.

**Kind**: static method of [Note](#module_Note) **Returns**: string -

the pitch class

| Param | Type | | --- | --- | | | string \| Pitch | **Example** ```js Note.pc("Db3") // => "Db" ["db3", "bb6", "fx2"].map(Note.pc) // => [ "Db", "Bb", "F##"] ``` ### Note.midiToFreq(note) ⇒ Number

Get the frequency of a note

**Kind**: static method of [Note](#module_Note) **Returns**: Number -

the frequency

| Param | Type | Description | | --- | --- | --- | | note | string \| Number |

the note name or midi note number

| **Example** ```js Note.freq("A4") // => 440 Note.freq(69) // => 440 ``` ### Note.chroma(note) ⇒ Integer

Get the octave of the given pitch

**Kind**: static method of [Note](#module_Note) **Returns**: Integer -

the octave or null if doesn"t have an octave or not a valid note

| Param | Type | Description | | --- | --- | --- | | note | string |

the note

| **Example** ```js Note.oct("C#4") // => 4 Note.oct("C") // => null Note.oct("blah") // => undefined ``` ### Note.altToAcc(props, [baseNote]) ⇒ string

Creates a note name in scientific notation from note properties, and optionally another note name. It receives an object with:

step: the note step (0 = C, 1 = D, ... 6 = B)
alt: (optional) the alteration. Negative numbers are flats, positive sharps
oct: (optional) the octave

Optionally it receives another note as a "base", meaning that any prop not explicitly received on the first parameter will be taken from that base note. That way it can be used as an immutable "set" operator for a that base note

**Kind**: static method of [Note](#module_Note) **Returns**: string -

the note name in scientific notation or null if not valid properties

| Param | Type | Description | | --- | --- | --- | | props | Object |

the note properties

| | [baseNote] | string |

note to build the result from. If given, it returns the result of applying the given props to this note.

| **Example** ```js Note.from({ step: 5 }) // => "A" Note.from({ step: 1, acc: -1 }) // => "Db" Note.from({ step: 2, acc: 2, oct: 2 }) // => "E##2" Note.from({ step: 7 }) // => null Note.from({alt: 1, oct: 3}, "C4") // => "C#3" ``` ### Note.build(midi, useSharps) ⇒ string

Given a midi number, returns a note name. The altered notes will have flats unless explicitly set with the optional useSharps parameter.

**Kind**: static method of [Note](#module_Note) **Returns**: string -

the note name

| Param | Type | Description | | --- | --- | --- | | midi | number |

the midi note number

| | useSharps | boolean |

(Optional) set to true to use sharps instead of flats

| **Example** ```js Note.fromMidi(61) // => "Db4" Note.fromMidi(61, true) // => "C#4" // it rounds to nearest note Note.fromMidi(61.7) // => "D4" ``` ### Note~props ⇒ Object

Get note properties. It returns an object with the following information:

name {string}: the note name. The letter is always in uppercase
letter {string}: the note letter, always in uppercase
acc {string}: the note accidentals
octave {Number}: the octave or null if not present
pc {string}: the pitch class (letter + accidentals)
step {Number}: number equivalent of the note letter. 0 means C ... 6 means B.
alt {Number}: number equivalent of accidentals (negative are flats, positive sharps)
chroma {Number}: number equivalent of the pitch class, where 0 is C, 1 is C# or Db, 2 is D...
midi {Number}: the note midi number (IMPORTANT! it can be outside 0 to 127 range)
freq {Number}: the frequency using an equal temperament at 440Hz

This function always returns an object with all this properties, but if it"s not a valid note all properties will be null.

The returned object can"t be mutated.

**Kind**: inner constant of [Note](#module_Note) **Returns**: Object -

an object with the properties (or an object will all properties set to null if not valid note)

| Param | Type | Description | | --- | --- | --- | | note | string |

the note name in scientific notation

| **Example** ```js Note.props("fx-3").name // => "F##-3" Note.props("invalid").name // => null Note.props("C#3").oct // => 3 Note.props().oct // => null ``` ### Note~names(accTypes) ⇒ Array

Get a list of note names (pitch classes) within a octave

**Kind**: inner method of [Note](#module_Note) | Param | Type | Description | | --- | --- | --- | | accTypes | string |

(Optional, by default " b#"). A string with the accidentals types: " " means no accidental, "#" means sharps, "b" mean flats, can be combined (see examples)

| **Example** ```js Note.names(" b") // => [ "C", "Db", "D", "Eb", "E", "F", "Gb", "G", "Ab", "A", "Bb", "B" ] Note.names(" #") // => [ "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" ] ``` ### Note~tokenize(str) ⇒ Array

Split a string into tokens related to note parts. It returns an array of strings [letter, accidental, octave, modifier]

It always returns an array

**Kind**: inner method of [Note](#module_Note) **Returns**: Array -

an array of note tokens

| Param | Type | | --- | --- | | str | string | **Example** ```js Note.tokenize("C#2") // => ["C", "#", "2", ""] Note.tokenize("Db3 major") // => ["D", "b", "3", "major"] Note.tokenize("major") // => ["", "", "", "major"] Note.tokenize("##") // => ["", "##", "", ""] Note.tokenize() // => ["", "", "", ""] ``` ### Note~midi(note) ⇒ Integer

Get the note midi number. It always return a number between 0 and 127

**Kind**: inner method of [Note](#module_Note) **Returns**: Integer -

the midi number or null if not valid pitch

**See**: midi.toMidi | Param | Type | Description | | --- | --- | --- | | note | string \| Number |

the note to get the midi number from

| **Example** ```js Note.midi("C4") // => 60 Note.midi(60) // => 60 ``` ### Note~freqToMidi(frequency) ⇒ Number

Get the midi number from a frequency in hertz. The midi number can contain decimals (with two digits precission)

**Kind**: inner method of [Note](#module_Note) | Param | Type | | --- | --- | | frequency | Number | **Example** ```js Note.freqToMidi(220)); //=> 57; Note.freqToMidi(261.62)); //=> 60; Note.freqToMidi(261)); //=> 59.96; ``` ### Note~stepToLetter(step) ⇒ string

Given a step number return it's letter (0 = C, 1 = D, 2 = E)

**Kind**: inner method of [Note](#module_Note) **Returns**: string -

the letter

| Param | Type | | --- | --- | | step | number | **Example** ```js Note.stepToLetter(3) // => "F" ``` ### Note~altToAcc(alt) ⇒ string

Given an alteration number, return the accidentals

**Kind**: inner method of [Note](#module_Note) | Param | Type | | --- | --- | | alt | Number | **Example** ```js Note.altToAcc(-3) // => "bbb" ``` ### Note~simplify(note, useSameAccType) ⇒ string

Simplify the note: find an enhramonic note with less accidentals.

**Kind**: inner method of [Note](#module_Note) **Returns**: string -

the simplfiied note or null if not valid note

| Param | Type | Description | | --- | --- | --- | | note | string |

the note to be simplified

| | useSameAccType | boolean |

(optional, true by default) set to true to ensure the returned note has the same accidental types that the given note

| **Example** ```js Note.simplify("C##") // => "D" Note.simplify("C###") // => "D#" Note.simplify("C###", false) // => "Eb" Note.simplify("B#4") // => "C5" ```