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
- static
- .midi ⇒
Number
- .freqToMidi ⇒
Integer
- .from
- .simplify ⇒
string
- .props() ⇒
string
- .name() ⇒
string
- .midiToFreq(note) ⇒
Number
- .chroma(note) ⇒
Integer
- .altToAcc(props, [baseNote]) ⇒
string
- .build(midi, useSharps) ⇒
string
- .midi ⇒
- inner
- ~props ⇒
Object
- ~names(accTypes) ⇒
Array
- ~tokenize(str) ⇒
Array
- ~midi(note) ⇒
Integer
- ~freqToMidi(frequency) ⇒
Number
- ~stepToLetter(step) ⇒
string
- ~altToAcc(alt) ⇒
string
- ~simplify(note, useSameAccType) ⇒
string
- ~props ⇒
- static
Number
Note.midi ⇒ Get the frequency from midi number
Kind: static property of 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 |
Integer
Note.freqToMidi ⇒ 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
Returns: Integer
-
the chroma number
Param | Type | Description |
---|---|---|
note | string |
the note name |
Example
Note // => 11"C" "D" "E" "F" // => [0, 2, 4, 5]
Note.from
Deprecated. This is kept for backwards compatibility only. Use Note.from instead
Kind: static property of Note
string
Note.simplify ⇒ Get the simplified and enhramonic note of the given one.
Kind: static property of Note
Returns: string
-
the enhramonic note
Param | Type |
---|---|
note | string |
Example
Note // => "C#"Note // => "C"
string
Note.props() ⇒ 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
Param | Type |
---|---|
Pitch | string |
Example
Notename"cb2" // => "Cb2""c" "db3" "2" "g+" "gx4" // => ["C", "Db3", null, null, "G##4"]
string
Note.name() ⇒ Get pitch class of a note. The note can be a string or a pitch array.
Kind: static method of Note
Returns: string
-
the pitch class
Param | Type |
---|---|
string | Pitch |
Example
Note // => "Db""db3" "bb6" "fx2" // => [ "Db", "Bb", "F##"]
Number
Note.midiToFreq(note) ⇒ Get the frequency of a note
Kind: static method of Note
Returns: Number
-
the frequency
Param | Type | Description |
---|---|---|
note | string | Number |
the note name or midi note number |
Example
Note // => 440Note // => 440
Integer
Note.chroma(note) ⇒ Get the octave of the given pitch
Kind: static method of 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
Note // => 4Note // => nullNote // => undefined
string
Note.altToAcc(props, [baseNote]) ⇒ 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
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
Note // => "A"Note // => "Db"Note // => "E##2"Note // => nullNote // => "C#3"
string
Note.build(midi, useSharps) ⇒ 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
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
Note // => "Db4"Note // => "C#4"// it rounds to nearest noteNote // => "D4"
Object
Note~props ⇒ 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
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
Notename // => "F##-3"Notename // => nullNoteoct // => 3Noteoct // => null
Array
Note~names(accTypes) ⇒ Get a list of note names (pitch classes) within a octave
Kind: inner method of 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
Note // => [ "C", "Db", "D", "Eb", "E", "F", "Gb", "G", "Ab", "A", "Bb", "B" ]Note // => [ "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" ]
Array
Note~tokenize(str) ⇒ 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
Returns: Array
-
an array of note tokens
Param | Type |
---|---|
str | string |
Example
Note // => ["C", "#", "2", ""]Note // => ["D", "b", "3", "major"]Note // => ["", "", "", "major"]Note // => ["", "##", "", ""]Note // => ["", "", "", ""]
Integer
Note~midi(note) ⇒ Get the note midi number. It always return a number between 0 and 127
Kind: inner method of 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
Note // => 60Note // => 60
Number
Note~freqToMidi(frequency) ⇒ Get the midi number from a frequency in hertz. The midi number can contain decimals (with two digits precission)
Kind: inner method of Note
Param | Type |
---|---|
frequency | Number |
Example
Note); //=> 57;Note); //=> 60;Note); //=> 59.96;
string
Note~stepToLetter(step) ⇒ Given a step number return it's letter (0 = C, 1 = D, 2 = E)
Kind: inner method of Note
Returns: string
-
the letter
Param | Type |
---|---|
step | number |
Example
Note // => "F"
string
Note~altToAcc(alt) ⇒ Given an alteration number, return the accidentals
Kind: inner method of Note
Param | Type |
---|---|
alt | Number |
Example
Note // => "bbb"
string
Note~simplify(note, useSameAccType) ⇒ Simplify the note: find an enhramonic note with less accidentals.
Kind: inner method of 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
Note // => "D"Note // => "D#"Note // => "Eb"Note // => "C5"