Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.javascript > #36397 > unrolled thread

Javascript "object creation" and object oriented programming

Back to article view | Back to comp.lang.javascript

Contents

  Javascript "object creation" and object oriented programming jonas.thornvall@gmail.com - 2019-04-23 23:50 -0700
    Re: Javascript "object creation" and object oriented programming jonas.thornvall@gmail.com - 2019-04-24 01:02 -0700
    Re: Javascript "object creation" and object oriented programming "R.Wieser" <address@not.available> - 2019-04-24 12:34 +0200
      Re: Javascript "object creation" and object oriented programming jonas.thornvall@gmail.com - 2019-04-24 05:41 -0700
        Re: Javascript "object creation" and object oriented programming "R.Wieser" <address@not.available> - 2019-04-24 18:06 +0200
    Re: Javascript "object creation" and object oriented programming jonas.thornvall@gmail.com - 2019-04-24 06:24 -0700
      Re: Javascript "object creation" and object oriented programming jonas.thornvall@gmail.com - 2019-04-24 07:00 -0700
    Re: Javascript "object creation" and object oriented programming John G Harris <niam@jghnorth.org.uk.invalid> - 2019-04-24 17:39 +0100
      Re: Javascript "object creation" and object oriented programming jonas.thornvall@gmail.com - 2019-04-24 11:01 -0700
        Re: Javascript "object creation" and object oriented programming John G Harris <niam@jghnorth.org.uk.invalid> - 2019-04-25 18:08 +0100
          Re: Javascript "object creation" and object oriented programming jonas.thornvall@gmail.com - 2019-04-25 10:14 -0700
      Re: Javascript "object creation" and object oriented programming jonas.thornvall@gmail.com - 2019-04-24 11:11 -0700
        Re: Javascript "object creation" and object oriented programming jonas.thornvall@gmail.com - 2019-04-24 13:50 -0700
          Re: Javascript "object creation" and object oriented programming jonas.thornvall@gmail.com - 2019-04-25 01:01 -0700
        Re: Javascript "object creation" and object oriented programming John G Harris <niam@jghnorth.org.uk.invalid> - 2019-04-25 18:12 +0100

#36397 — Javascript "object creation" and object oriented programming

I really feel uncomfortable when it comes to object and their structures, to much multidimensional array programming i guess.

So i have a hard time to grip howto actually make the objects to store data.

Let us say i have a synth object, each synth have bank index and the banks have names, each bank have instrument index and the instruments have names.

Now each instruments have notes with index and the notes have names. Maybe my attempt below is correct but it just feel so wrong? It somehow miss the depth aspect of multidimensional arrays?

function newCollection(m) {
  extSynth[m] = {
    synth : "",
    bank: [],
    bankname : "",
    prg : [],
    prgname :"",
    note : [],
    notenname : "",
  };
  return newCollection;
}

[toc] | [next] | [standalone]

#36398

Den onsdag 24 april 2019 kl. 08:50:59 UTC+2 skrev jonas.t...@gmail.com:
> I really feel uncomfortable when it comes to object and their structures, to much multidimensional array programming i guess.
> 
> So i have a hard time to grip howto actually make the objects to store data.
> 
> Let us say i have a synth object, each synth have bank index and the banks have names, each bank have instrument index and the instruments have names.
> 
> Now each instruments have notes with index and the notes have names. Maybe my attempt below is correct but it just feel so wrong? It somehow miss the depth aspect of multidimensional arrays?
> 
> function newCollection(m) {
>   extSynth[m] = {
>     synth : "",
>     bank: [],
>     bankname : "",
>     prg : [],
>     prgname :"",
>     note : [],
>     notenname : "",
>   };
>   return newCollection;
> }

Found something about nested objects, maybe this is the way to do it.

function newCollection(m) {
  extSynth[m] = {
    Csynth : "",
    Cbank[]={
       Cbankname : "",
       Cprg[]={
          Cprgname :"",
             Cnote[]={
               Cnotenname : "",
			 }
       }
    }	   
  };
  return extSynth;
}

Found a nice site, i am not sure the above is correct syntax, because they had no objects arrays just arrays in objects?


https://www.sitepoint.com/back-to-basics-javascript-object-syntax/

[toc] | [prev] | [next] | [standalone]

#36399

Jonas,

> So i have a hard time to grip howto actually make the objects to store 
> data.

It looks to me you are mixing up objects and arrays.

The below website shows the usage of arrays withoud using actual objects or 
functions for it:

https://eloquentjavascript.net/04_data.html

This one shows what I call an /object/ (as in: having properties and/or 
methods) and how to store varaibles and array into it.

https://stackoverflow.com/questions/14652504/performance-using-array-in-the-object-namespace-vs-local-array

Also, your "function newCollection(m)" returns a pointer to the function 
itself(?), not to the array you created -which will be discarded (it 
disappears) as soon as you leave that function.  In other words: you should 
be using "return extSynth();".

But that creates its own problem, as you will than return the /whole/ array 
(with all the "objects" in it), not just the one you just created.

Yeah, it looks like you mixed up a few things there.  Have you ever tried to 
access (read, write, read - in that order) that returned object ?   And ? 
What happened ? :-)

Regards,
Rudy Wieser

[toc] | [prev] | [next] | [standalone]

#36400

Den onsdag 24 april 2019 kl. 12:34:55 UTC+2 skrev R.Wieser:
> Jonas,
> 
> > So i have a hard time to grip howto actually make the objects to store 
> > data.
> 
> It looks to me you are mixing up objects and arrays.
> 
> The below website shows the usage of arrays withoud using actual objects or 
> functions for it:
> 
> https://eloquentjavascript.net/04_data.html
> 
> This one shows what I call an /object/ (as in: having properties and/or 
> methods) and how to store varaibles and array into it.
> 
> https://stackoverflow.com/questions/14652504/performance-using-array-in-the-object-namespace-vs-local-array
> 
> Also, your "function newCollection(m)" returns a pointer to the function 
> itself(?), not to the array you created -which will be discarded (it 
> disappears) as soon as you leave that function.  In other words: you should 
> be using "return extSynth();".
> 
> But that creates its own problem, as you will than return the /whole/ array 
> (with all the "objects" in it), not just the one you just created.
> 
> Yeah, it looks like you mixed up a few things there.  Have you ever tried to 
> access (read, write, read - in that order) that returned object ?   And ? 
> What happened ? :-)
> 
> Regards,
> Rudy Wieser

Well i will read in the values from a textfile, as i proposed in second example we will see if the structure is viable.

[toc] | [prev] | [next] | [standalone]

#36403

Jonas,

> Well i will read in the values from a textfile,

Not relevant (and for *testing purposes* I suggest you forget all about it).

> as i proposed in second example we will see if the
> structure is viable.

That would be as basic as just writing (something like) "foo" into the 
"bankname" field and than check if you can read it back.    I don't think 
you can, but I could be wrong ...

Regards
Rudy Wieser

[toc] | [prev] | [next] | [standalone]

#36401

Den onsdag 24 april 2019 kl. 08:50:59 UTC+2 skrev jonas.t...@gmail.com:
> I really feel uncomfortable when it comes to object and their structures, to much multidimensional array programming i guess.
> 
> So i have a hard time to grip howto actually make the objects to store data.
> 
> Let us say i have a synth object, each synth have bank index and the banks have names, each bank have instrument index and the instruments have names.
> 
> Now each instruments have notes with index and the notes have names. Maybe my attempt below is correct but it just feel so wrong? It somehow miss the depth aspect of multidimensional arrays?
> 
> function newCollection(m) {
>   extSynth[m] = {
>     synth : "",
>     bank: [],
>     bankname : "",
>     prg : [],
>     prgname :"",
>     note : [],
>     notenname : "",
>   };
>   return newCollection;
> }

Well this is the approach i use for tracks, and it works good for that purpose since it do not need to be nested.

The instrument object is trickier since you need at least 3 levels "or 4" depending on if you put together bank and prg or do them separate. Since they are basicly just an index with properties you could have them together. But somehow notes is an array of instrument. And i do not really understand how to get there "today".

function newTrack(m) {
  track[m] = {
    outport: [],
    portname: [],
    bank:[],
    midichannel: [],
    program: [],
    trackname:"" ,
    midiMess: [],
    //CONFIGURATION OF midiMess:[{time:0,data0:0,data1:0,data2:0}]
  };
  return track;
}

var pianoroll = [];

function makeTrack() {
   maxtrack=16;
  for (var m = 0; m <= maxtrack; m++) {
    newTrack(m);
    settingsTrack(m);
  }
 defaultTrackInstruments();
 listAllTrackSettings();
}

[toc] | [prev] | [next] | [standalone]

#36402

Den onsdag 24 april 2019 kl. 15:24:33 UTC+2 skrev jonas.t...@gmail.com:
> Den onsdag 24 april 2019 kl. 08:50:59 UTC+2 skrev jonas.t...@gmail.com:
> > I really feel uncomfortable when it comes to object and their structures, to much multidimensional array programming i guess.
> > 
> > So i have a hard time to grip howto actually make the objects to store data.
> > 
> > Let us say i have a synth object, each synth have bank index and the banks have names, each bank have instrument index and the instruments have names.
> > 
> > Now each instruments have notes with index and the notes have names. Maybe my attempt below is correct but it just feel so wrong? It somehow miss the depth aspect of multidimensional arrays?
> > 
> > function newCollection(m) {
> >   extSynth[m] = {
> >     synth : "",
> >     bank: [],
> >     bankname : "",
> >     prg : [],
> >     prgname :"",
> >     note : [],
> >     notenname : "",
> >   };
> >   return newCollection;
> > }
> 
> Well this is the approach i use for tracks, and it works good for that purpose since it do not need to be nested.
> 
> The instrument object is trickier since you need at least 3 levels "or 4" depending on if you put together bank and prg or do them separate. Since they are basicly just an index with properties you could have them together. But somehow notes is an array of instrument. And i do not really understand how to get there "today".
> 
> function newTrack(m) {
>   track[m] = {
>     outport: [],
>     portname: [],
>     bank:[],
>     midichannel: [],
>     program: [],
>     trackname:"" ,
>     midiMess: [],
>     //CONFIGURATION OF midiMess:[{time:0,data0:0,data1:0,data2:0}]
>   };
>   return track;
> }
> 
> var pianoroll = [];
> 
> function makeTrack() {
>    maxtrack=16;
>   for (var m = 0; m <= maxtrack; m++) {
>     newTrack(m);
>     settingsTrack(m);
>   }
>  defaultTrackInstruments();
>  listAllTrackSettings();
> }

I made my own synth instrument format just to be annoying, but that way i can use my own created start and endbrackets and file get easier to handle.

Here i load the file into structure "an object i do not know howto create" but i know howto read out file of my own format. And below code is synth fileformat that i want a sound structure for.

ATXT=loadFile('http://127.0.0.1/synths/sc-7.html');
document.getElementById("soundcollection").value=ATXT;
loadCollection(ATXT);

function loadFile(filePath) {
  var result = null;
  var xmlhttp = new XMLHttpRequest();
  xmlhttp.open("GET", loadFile, false);
  xmlhttp.send();
  if (xmlhttp.status==200) {
    result = xmlhttp.responseText;
  }
  return result;
}

function loadCollection(ATXT){
console.log("I AM HERE");
LASTCOLLECTION=false;
LASTBANK=false;
LASTINSTRUMENT=false;
LASTNOTE=false;
var LC=0, LB=0, LI=0, LN=0; 

  while(!LASTCOLLECTION){
	  
     var synthSTART = ATXT.indexOf("SYNTH*/",LC);
     var synthEND = ATXT.indexOf("/*",LC);
     var Asynth=ATXT.substring(synthSTART+8,synthEND);
	 extSynth[LC].Csynth=Asynth;
     console.log(extSynth[LC].Csynth);
     LC++;
	 if(synthSTART==-1){LASTCOLLECTION=true};
       while(!LASTBANK) {
		  var bnkSTART = ATXT.indexOf("BANKLOAD/*",LB);
		  var bnkEND = ATXT.indexOf("*/",LB);
		  var Abank=ATXT.substring(bnkSTART+10,bnkEND);
          LB++;		
		  if(bnkSTART==-1){LASTBANK=true};
          console.log(Abank);		  
            while (!LASTINSTRUMENT){
		       var instSTART = ATXT.indexOf("[*",LI);
		       var instEND = ATXT.indexOf("*]",LI);
		       var Ainstr=ATXT.substring(instSTART+5,instEND);
			   LI++;
			   if(instSTART==-1){LASTINSTRUMENT=true};
			   console.log(Ainstr);
               while (!LASTNOTE){  
                   var noteSTART = ATXT.indexOf("'\n'",LN);
		           var noteEND = ATXT.indexOf("*]]",LN);
		           var Anote=ATXT.substring(noteSTART+3,noteEND);
				   LN++;
				//   console.log(Anote);
				   if(noteSTART==-1){LASTNOTE=true};
               }
          }
      }

   }

}
 

SYNTH*/Roland SC-7/*

BANKLOAD/*(0,0)*/

[*(144,1) Piano 1*]
[*(144,2) Piano 2*]
[*(144,3) Piano 3*]
[*(144,4) Honky-tonk*]
[*(144,5) E.Piaon 1*]
[*(144,6) E.Piano 2*]
[*(144,7) Harpsichiord*]
[*(144,8) Clav*]
[*(144,9) Celeste*]
[*(144,10) Glockenspiel*]
[*(144,11) Music Box*]
[*(144,12) Vibraphone*]
[*(144,13) Marimba*]
[*(144,14) Xylophone*]
[*(144,15) Tubular-bell*]
[*(144,16) Dulcimer*]
[*(144,17) Organ 1*]
[*(144,18) Organ 2*]
[*(144,19) Organ 3*]
[*(144,20) Church Org.1*]
[*(144,21) Reed Org.1*]
[*(144,22) Accordion Fr*]
[*(144,23) Harmonica*]
[*(144,24) Tango Accordion*]
[*(144,25) Nylon-str.Gt*]
[*(144,26) Steel-str.Gt*]
[*(144,27) Jazz Gt*]
[*(144,28) Clean Gt*]
[*(144,29) Mutet Gt*]
[*(144,30) Overdrive Gt*]
[*(144,31) Distorsion Gt*]
[*(144,32) Gt Harmonics*]
[*(144,33) Acoustic Bs.*]
[*(144,34) Fingered Bs.*]
[*(144,35) Picked Bs.*]
[*(144,36) Fretless Bs.*]
[*(144,37) Slap Bass 1*]
[*(144,38) Slap Bass 2*]
[*(144,39) Synth Bass 1*]
[*(144,40) Synth Bass 2*]
[*(144,41) Violin*]
[*(144,42) Viola*]
[*(144,43) Cello*]
[*(144,44) Contrabass*]
[*(144,45) Tremolo Str*]
[*(144,46) Pizzicato Str*]
[*(144,47) Harp *]
[*(144,48) Timpani *]
[*(144,49) Strings*]
[*(144,50) Slow strings*]
[*(144,51) Syn Strings*]
[*(144,52) Syn Strings 2*]
[*(144,53) Choir Aahs*]
[*(144,54) Voice Oohs*]
[*(144,55) SynVox*]
[*(144,56) Orchestra Hit*]
[*(144,57) Trumpet*]
[*(144,58) Trombone*]
[*(144,59) Tuba*]
[*(144,60) Muted Trumpet*]
[*(144,61) French Horn*]
[*(144,62) Brass 1*]
[*(144,63) Synth Brass 1*]
[*(144,64) Synth Brass 2*]
[*(144,65) Sophrano Sax*]
[*(144,66) Alto Sax*]
[*(144,67) Tenor Sax*]
[*(144,68) Baritone Sax*]
[*(144,69) Oboe*]
[*(144,70) English Horn*]
[*(144,71) Bassoon*]
[*(144,72) Clarinet*]
[*(144,73) Piccolo*]
[*(144,74) Flute*]
[*(144,75) Recorder*]
[*(144,76) Pan Flute*]
[*(144,77) Bottle Blow*]
[*(144,78) Shakuhachi*]
[*(144,79) Whistle*]
[*(144,80) Ocarina*]
[*(144,81) Square Wave*]
[*(144,82) Saw Wave*]
[*(144,83) Syn Calliope*]
[*(144,84) Chiffer Lead*]
[*(144,85) Charang*]
[*(144,86) Solo Vox*]
[*(144,87) 5th Saw Wave*]
[*(144,88) Bass & Lead*]
[*(144,89) Fantasia*]
[*(144,90) Warmpad*]
[*(144,91) Polysynth*]
[*(144,92) Space Voice*]
[*(144,93) Bowed Glass*]
[*(144,94) Metal Pad*]
[*(144,95) Halo Pad*]
[*(144,96) Sweel Pad*]
[*(144,97) Ice Rain*]
[*(144,98) Soundtrack*]
[*(144,99) Crystal*]
[*(144,100) Atmosphere*]
[*(144,101) Brightness*]
[*(144,102) Goblin*]
[*(144,103) Echo Drops*]
[*(144,104) Star Theme*]
[*(144,105) Sitar*]
[*(144,106) Banjo*]
[*(144,107) Shamisen*]
[*(144,108) Koto*]
[*(144,109) Kalimba*]
[*(144,110) Bag Pipe*]
[*(144,111) Fiddle*]
[*(144,112) Shannai*]
[*(144,113) Tinkle Bell*]
[*(144,114) Agogo*]
[*(144,115) Steel Drums*]
[*(144,116) Woodblock*]
[*(144,117) Taiko*]
[*(144,118) Melo. Tom 1*]
[*(144,119) Synth Drum*]
[*(144,120) Reverse Cym.*]
[*(144,121) Gt.FretNoise*]
[*(144,122) Breath Noise*]
[*(144,123) Seashore*]
[*(144,124) Bird*]
[*(144,125) Telephone 1*]
[*(144,126) Helicopter*]
[*(144,127) Applause*]

[*(153,1) Standard set*]
/@(27) High Q@/
/@(28) Slap@/
/@(29) Scratch Push@/
/@(30) Scratch Pull@/
/@(31) Sticks@/
/@(32) Square Click@/
/@(33) Metronome Click@/
/@(34) Metronome Bell@/
/@(35) Kick Drum 2@/
/@(36) Kick Drum 1@/
/@(37) Side Stick@/
/@(38) Snare Drum 1@/
/@(39) Hand Clap@/
/@(40) Snare Drum 2@/
/@(41) Low Tom 2@/
/@(42) Close Hi-hat@/
/@(43) Low Tom 1@/
/@(44) Pedal Hi-Hat@/
/@(45) Mid Tom 2@/
/@(46) Open Hi-Hat@/
/@(47) Mid Tom 1@/
/@(48) High Tom 2@/
/@(49) Crasch Cymbal 1@/
/@(50) High Tom 1@/
/@(51) Ride Cymbal 1@/
/@(52) Chinese Cymbal@/
/@(53) Ride Bell@/
/@(54) Tambourine@/
/@(55) Splash Cymbal@/
/@(56) Cowbell@/
/@(57) Crash Cymbal 2@/
/@(58) Vibra-slap@/
/@(59) Ride Cymbal 2@/
/@(60) High Bongo@/
/@(61) Low Bongo@/
/@(62) Mute High Conga@/
/@(63) Open High Conga@/
/@(64) Low Conga@/
/@(65) High Timbale@/
/@(66) Low Timbale@/
/@(67) High Agogo@/
/@(68) Low Agogo@/
/@(69) Cabasa@/
/@(70) Maracas@/
/@(71) Short Hi Whistle@/
/@(72) Long Low Whistle@/
/@(73) Short Guiro@/
/@(74) Long Guilro@/
/@(75) Claves@/
/@(76) High Wood Block@/
/@(77) Low Wood Block@/
/@(78) Mute Cuica@/
/@(79) Open Cuica@/
/@(80) Mute Triangle@/
/@(81) Open Triangle@/
/@(82) Shaker@/
/@(83) Jingle Bell@/
/@(84) @/
/@(85) Castanets@/
/@(86) Mute Surdo@/
/@(87) Open Surdo@/
/@(88) @/

[*(153,17) Power set*]
/@(27) High Q@/
/@(28) Slap@/
/@(29) Scratch Push@/
/@(30) Scratch Pull@/
/@(31) Sticks@/
/@(32) Square Click@/
/@(33) Metronome Click@/
/@(34) Metronome Bell@/
/@(35) Kick Drum 2@/
/@(36) *MONDO Kick*@/
/@(37) Side Stick@/
/@(38) *Gated SD*@/
/@(39) Hand Clap@/
/@(40) Snare Drum 2@/
/@(41) Low Tom 2@/
/@(42) Close Hi-hat@/
/@(43) Low Tom 1@/
/@(44) Pedal Hi-Hat@/
/@(45) Mid Tom 2@/
/@(46) Open Hi-Hat@/
/@(47) Mid Tom 1@/
/@(48) High Tom 2@/
/@(49) Crasch Cymbal 1@/
/@(50) High Tom 1@/
/@(51) Ride Cymbal 1@/
/@(52) Chinese Cymbal@/
/@(53) Ride Bell@/
/@(54) Tambourine@/
/@(55) Splash Cymbal@/
/@(56) Cowbell@/
/@(57) Crash Cymbal 2@/
/@(58) Vibra-slap@/
/@(59) Ride Cymbal 2@/
/@(60) High Bongo@/
/@(61) Low Bongo@/
/@(62) Mute High Conga@/
/@(63) Open High Conga@/
/@(64) Low Conga@/
/@(65) High Timbale@/
/@(66) Low Timbale@/
/@(67) High Agogo@/
/@(68) Low Agogo@/
/@(69) Cabasa@/
/@(70) Maracas@/
/@(71) Short Hi Whistle@/
/@(72) Long Low Whistle@/
/@(73) Short Guiro@/
/@(74) Long Guilro@/
/@(75) Claves@/
/@(76) High Wood Block@/
/@(77) Low Wood Block@/
/@(78) Mute Cuica@/
/@(79) Open Cuica@/
/@(80) Mute Triangle@/
/@(81) Open Triangle@/
/@(82) Shaker@/
/@(83) Jingle Bell@/
/@(84) @/
/@(85) Castanets@/
/@(86) Mute Surdo@/
/@(87) Open Surdo@/
/@(88) @/

[*(153,25) Elec. set*]
/@(27) High Q
/@(28) Slap
/@(29) Scratch Push
/@(30) Scratch Pull
/@(31) Sticks
/@(32) Square Click
/@(33) Metronome Click
/@(34) Metronome Bell
/@(35) Kick Drum 2
/@(36) *Elec BD*
/@(37) Side Stick
/@(38) *Elec SD*
/@(39) Hand Clap
/@(40) *Gated SD*
/@(41) *Elec LowTom 1
/@(42) Close Hi-hat
/@(43) *Elec LowTom 2
/@(44) Pedal Hi-Hat
/@(45) *Elec MidTom 1
/@(46) Open Hi-Hat
/@(47) *Elec MidTom 2*
/@(48) *Elec HiTom 2*
/@(49) Crasch Cymbal 1
/@(50) *Elec HiTom 1*
/@(51) Ride Cymbal 1
/@(52) *Reverse Cymbal*
/@(53) Ride Bell
/@(54) Tambourine
/@(55) Splash Cymbal
/@(56) Cowbell
/@(57) Crash Cymbal 2
/@(58) Vibra-slap
/@(59) Ride Cymbal 2
/@(60) High Bongo
/@(61) Low Bongo
/@(62) Mute High Conga
/@(63) Open High Conga
/@(64) Low Conga
/@(65) High Timbale
/@(66) Low Timbale
/@(67) High Agogo
/@(68) Low Agogo
/@(69) Cabasa
/@(70) Maracas
/@(71) Short Hi Whistle
/@(72) Long Low Whistle
/@(73) Short Guiro
/@(74) Long Guilro
/@(75) Claves
/@(76) High Wood Block
/@(77) Low Wood Block
/@(78) Mute Cuica
/@(79) Open Cuica
/@(80) Mute Triangle
/@(81) Open Triangle
/@(82) Shaker
/@(83) Jingle Bell
/@(84) 
/@(85) Castanets
/@(86) Mute Surdo
/@(87) Open Surdo
/@(88) 

[*(153,26) TR-808*]
/@(27) High Q
/@(28) Slap
/@(29) Scratch Push
/@(30) Scratch Pull
/@(31) Sticks
/@(32) Square Click
/@(33) Metronome Click
/@(34) Metronome Bell
/@(35) Kick Drum 2
/@(36) *808 Bass Drum*
/@(37) *808 Rim Shot*
/@(38) *808 Snare Drum*
/@(39) Hand Clap
/@(40) Snare Drum 2
/@(41) *808 Low Tom 2*
/@(42) *808 CHH EXC 1*
/@(43) *808 Low tom 1*
/@(44) *808 CHH EXC 2*
/@(45) *808 Mid Tom 2*
/@(46) *808 OHH EXC 1*
/@(47) *808 Mid Tom 1*
/@(48) *808 Hi Tom 2*
/@(49) *808 Cymbal*
/@(50) *808 Hi Tom 1*
/@(51) Ride Cymbal 1
/@(52) Chinese Cymbal
/@(53) Ride Bell
/@(54) Tambourine
/@(55) Splash Cymbal
/@(56) *808 Cowbell*
/@(57) Crash Cymbal 2
/@(58) Vibra-slap
/@(59) Ride Cymbal 2
/@(60) High Bongo
/@(61) Low Bongo
/@(62) *808 High Conga*
/@(63) *808 Mid Conga* 
/@(64) *808 Low Conga*
/@(65) High Timbale
/@(66) Low Timbale
/@(67) High Agogo
/@(68) Low Agogo
/@(69) Cabasa
/@(70) *808 Maracas*
/@(71) Short Hi Whistle
/@(72) Long Low Whistle
/@(73) Short Guiro
/@(74) Long Guilro
/@(75) *808 Claves*
/@(76) High Wood Block
/@(77) Low Wood Block
/@(78) Mute Cuica
/@(79) Open Cuica
/@(80) Mute Triangle
/@(81) Open Triangle
/@(82) Shaker
/@(83) Jingle Bell
/@(84) 
/@(85) Castanets
/@(86) Mute Surdo
/@(87) Open Surdo
/@(88) 

[*(153,41) Brush set*]
/@(27) High Q
/@(28) Slap
/@(29) Scratch Push
/@(30) Scratch Pull
/@(31) Sticks
/@(32) Square Click
/@(33) Metronome Click
/@(34) Metronome Bell
/@(35) Kick Drum 2
/@(36) Kick Drum 1
/@(37) Side Stick
/@(38) *Brush Swish*
/@(39) *Brush Slap*
/@(40) *Brush Swirl*
/@(41) Low Tom 2
/@(42) Close Hi-hat
/@(43) Low Tom 1
/@(44) Pedal Hi-Hat
/@(45) Mid Tom 2
/@(46) Open Hi-Hat
/@(47) Mid Tom 1
/@(48) High Tom 2
/@(49) Crasch Cymbal 1
/@(50) High Tom 1
/@(51) Ride Cymbal 1
/@(52) Chinese Cymbal
/@(53) Ride Bell
/@(54) Tambourine
/@(55) Splash Cymbal
/@(56) Cowbell
/@(57) Crash Cymbal 2
/@(58) Vibra-slap
/@(59) Ride Cymbal 2
/@(60) High Bongo
/@(61) Low Bongo
/@(62) Mute High Conga
/@(63) Open High Conga
/@(64) Low Conga
/@(65) High Timbale
/@(66) Low Timbale
/@(67) High Agogo
/@(68) Low Agogo
/@(69) Cabasa
/@(70) Maracas
/@(71) Short Hi Whistle
/@(72) Long Low Whistle
/@(73) Short Guiro
/@(74) Long Guilro
/@(75) Claves
/@(76) High Wood Block
/@(77) Low Wood Block
/@(78) Mute Cuica
/@(79) Open Cuica
/@(80) Mute Triangle
/@(81) Open Triangle
/@(82) Shaker
/@(83) Jingle Bell
/@(84) 
/@(85) Castanets
/@(86) Mute Surdo
/@(87) Open Surdo
/@(88) 

[*(153,49) Orchestra set*]
/@(27) *Close HH*
/@(28) *Pedal HH*
/@(29) *Open HH*
/@(30) *Ride Cymbal*
/@(31) Sticks
/@(32) Square Click
/@(33) Metronome Click
/@(34) Metronome Bell
/@(35) *Concert BD2*
/@(36) *Concert BD1*
/@(37) Side Stick
/@(38) *Concert SD*
/@(39) *Castanets*
/@(40) *Concert SD 2*
/@(41) *Timpani F*
/@(42) *Timpani F#*
/@(43) *Timpani G*
/@(44) *Timpani G#*
/@(45) *Timpani A*
/@(46) *Timpani A#*
/@(47) *Timpani B*
/@(48) *Timpani C*
/@(49) *Timpani C#*
/@(50) *Timpani D*
/@(51) *Timpani D#*
/@(52) *Timpani E*
/@(53) *Timpani F*
/@(54) Tambourine
/@(55) Splash Cymbal
/@(56) Cowbell
/@(57) *Concert Cymbal 2*
/@(58) *Concert Cymbal 1*
/@(59) Ride Cymbal 2
/@(60) High Bongo
/@(61) Low Bongo
/@(62) Mute High Conga
/@(63) Open High Conga
/@(64) Low Conga
/@(65) High Timbale
/@(66) Low Timbale
/@(67) High Agogo
/@(68) Low Agogo
/@(69) Cabasa
/@(70) Maracas
/@(71) Short Hi Whistle
/@(72) Long Low Whistle
/@(73) Short Guiro
/@(74) Long Guilro
/@(75) Claves
/@(76) High Wood Block
/@(77) Low Wood Block
/@(78) Mute Cuica
/@(79) Open Cuica
/@(80) Mute Triangle
/@(81) Open Triangle
/@(82) Shaker
/@(83) Jingle Bell
/@(84) 
/@(85) Castanets
/@(86) Mute Surdo
/@(87) Open Surdo
/@(88) *Applause*

[toc] | [prev] | [next] | [standalone]

#36404

On Tue, 23 Apr 2019 23:50:46 -0700 (PDT), jonas.thornvall@gmail.com
wrote:

  <snip>
>Let us say i have a synth object, each synth have bank index and the banks have names, each bank have instrument index and the instruments have names.

Please stop sayint it's a bank index. It's a lot less confusing to say
it clearly : it's a list or sequence of banks. 

The same goes for the other things you've called an index.


>Now each instruments have notes with index and the notes have names. Maybe my attempt below is correct but it just feel so wrong? It somehow miss the depth aspect of multidimensional arrays?
  <snip>

So, what you've described can be summarised as :

  A synth object is
    a list of banks

  A bank is
    a name, and
    a list of instruments

  An instrument is
    a name, and
    a list of notes

  A note is
    a name


You can now see that you have four kinds of object. Each has two
properties :

  name, possibly null
  list, possibly null

A non-null name will be a string.
A non-null list will be an array.


  John

[toc] | [prev] | [next] | [standalone]

#36405

Den onsdag 24 april 2019 kl. 18:39:23 UTC+2 skrev John G Harris:
> On Tue, 23 Apr 2019 23:50:46 -0700 (PDT), jonas.thornvall@gmail.com
> wrote:
> 
>   <snip>
> >Let us say i have a synth object, each synth have bank index and the banks have names, each bank have instrument index and the instruments have names.
> 
> Please stop sayint it's a bank index. It's a lot less confusing to say
> it clearly : it's a list or sequence of banks. 

But is not all the "objects" "subobjects" "synth,bank,instrument,note" reachable by selecting the index? That is how i use the track object track is reachable by an index, and it has a property its name?

You say that is wrong approach?

I was thinking i have synths that have index, and a property of it is name, another property is the subindex (Nested object?) of the bank? It has also a name and also a subindex (Nested object?) and so on...

Do you say it is the wrong way to think about the object?


I see you choose to separate the objects "below", instead of nest them will that not make it harder to read in and out things from the objects?

Lets say i want the read out a "drumname" it equals note 23 name, of instrument X, in bank Y, in synth Z
How do you do that?

It seem to me a nested structure you can do it in one swoop?


> The same goes for the other things you've called an index.
> 
> 
> >Now each instruments have notes with index and the notes have names. Maybe my attempt below is correct but it just feel so wrong? It somehow miss the depth aspect of multidimensional arrays?
>   <snip>
> 
> So, what you've described can be summarised as :
> 
>   A synth object is
>     a list of banks
> 
>   A bank is
>     a name, and
>     a list of instruments
> 
>   An instrument is
>     a name, and
>     a list of notes
> 
>   A note is
>     a name
> 
> 
> You can now see that you have four kinds of object. Each has two
> properties :
> 
>   name, possibly null
>   list, possibly null
> 
> A non-null name will be a string.
> A non-null list will be an array.
> 
> 
>   John

[toc] | [prev] | [next] | [standalone]

#36417

On Wed, 24 Apr 2019 11:01:43 -0700 (PDT), jonas.thornvall@gmail.com
wrote:

>Den onsdag 24 april 2019 kl. 18:39:23 UTC+2 skrev John G Harris:
>> On Tue, 23 Apr 2019 23:50:46 -0700 (PDT), jonas.thornvall@gmail.com
>> wrote:
>> 
>>   <snip>
>> >Let us say i have a synth object, each synth have bank index and the banks have names, each bank have instrument index and the instruments have names.
>> 
>> Please stop sayint it's a bank index. It's a lot less confusing to say
>> it clearly : it's a list or sequence of banks. 
  <snip>

>I was thinking i have synths that have index, and a property of it is name, another property is the subindex (Nested object?) of the bank? It has also a name and also a subindex (Nested object?) and so on...
>
>Do you say it is the wrong way to think about the object?

I'm saying it's the wrong way to describe it. An "index" is just a
number. It says which thing in the list is the one you want. The list
of banks in a synth looks like :

  Things        :  [bank, bank, bank, ...]
  Index numbers :    0     1     2    ...

Obviously you would store this list of bank objects in an array. If
the array is held in a variable named banks then
  banks[2]
accesses the bank in the list whose index number is 2.


>I see you choose to separate the objects "below", instead of nest them will that not make it harder to read in and out things from the objects?
>
>Lets say i want the read out a "drumname" it equals note 23 name, of instrument X, in bank Y, in synth Z
>How do you do that?
>
>It seem to me a nested structure you can do it in one swoop?
  <snip>

What I said is that 
  each synth has several banks, 
  each bank in each synth has several instruments, 
  each instrument in each bank in each synth has several notes.

That's what you will see in the structure of a synth. Obviously, it's
a nested structure. Now that the structure has been described you can
decide what objects, etc, you are going to use to implement one of
these stuctures.

  John

[toc] | [prev] | [next] | [standalone]

#36419

Den torsdag 25 april 2019 kl. 19:08:15 UTC+2 skrev John G Harris:
> On Wed, 24 Apr 2019 11:01:43 -0700 (PDT), jonas.thornvall@gmail.com
> wrote:
> 
> >Den onsdag 24 april 2019 kl. 18:39:23 UTC+2 skrev John G Harris:
> >> On Tue, 23 Apr 2019 23:50:46 -0700 (PDT), jonas.thornvall@gmail.com
> >> wrote:
> >> 
> >>   <snip>
> >> >Let us say i have a synth object, each synth have bank index and the banks have names, each bank have instrument index and the instruments have names.
> >> 
> >> Please stop sayint it's a bank index. It's a lot less confusing to say
> >> it clearly : it's a list or sequence of banks. 
>   <snip>
> 
> >I was thinking i have synths that have index, and a property of it is name, another property is the subindex (Nested object?) of the bank? It has also a name and also a subindex (Nested object?) and so on...
> >
> >Do you say it is the wrong way to think about the object?
> 
> I'm saying it's the wrong way to describe it. An "index" is just a
> number. It says which thing in the list is the one you want. The list
> of banks in a synth looks like :
> 
>   Things        :  [bank, bank, bank, ...]
>   Index numbers :    0     1     2    ...
> 
> Obviously you would store this list of bank objects in an array. If
> the array is held in a variable named banks then
>   banks[2]
> accesses the bank in the list whose index number is 2.
> 
> 
> >I see you choose to separate the objects "below", instead of nest them will that not make it harder to read in and out things from the objects?
> >
> >Lets say i want the read out a "drumname" it equals note 23 name, of instrument X, in bank Y, in synth Z
> >How do you do that?
> >
> >It seem to me a nested structure you can do it in one swoop?
>   <snip>
> 
> What I said is that 
>   each synth has several banks, 
>   each bank in each synth has several instruments, 
>   each instrument in each bank in each synth has several notes.
> 
> That's what you will see in the structure of a synth. Obviously, it's
> a nested structure. Now that the structure has been described you can
> decide what objects, etc, you are going to use to implement one of
> these stuctures.
> 
>   John

I guess John there is no syntax examples to find, with nested objects that are arrays otherwise i would be done by now.

[toc] | [prev] | [next] | [standalone]

#36406

Den onsdag 24 april 2019 kl. 18:39:23 UTC+2 skrev John G Harris:
> On Tue, 23 Apr 2019 23:50:46 -0700 (PDT), jonas.thornvall@gmail.com
> wrote:
> 
>   <snip>
> >Let us say i have a synth object, each synth have bank index and the banks have names, each bank have instrument index and the instruments have names.
> 
> Please stop sayint it's a bank index. It's a lot less confusing to say
> it clearly : it's a list or sequence of banks. 
> 
> The same goes for the other things you've called an index.
> 
> 
> >Now each instruments have notes with index and the notes have names. Maybe my attempt below is correct but it just feel so wrong? It somehow miss the depth aspect of multidimensional arrays?
>   <snip>
> 
> So, what you've described can be summarised as :
> 
>   A synth object is
>     a list of banks
> 
>   A bank is
>     a name, and
>     a list of instruments
> 
>   An instrument is
>     a name, and
>     a list of notes
> 
>   A note is
>     a name
> 
> 
> You can now see that you have four kinds of object. Each has two
> properties :
> 
>   name, possibly null
>   list, possibly null
> 
> A non-null name will be a string.
> A non-null list will be an array.
> 
> 
>   John

Here is my track object. As you can see it is easy to read out name port midichannel events, well one could quiestion why one would have all of them as arrays, but maybe there is bankchange or midichannelchange or programchange on the track.

But one thing is clear midi events midiMess[] is an array of sequential events that i push in "3 data bytes and a time".

Would not this kind of structure but with more levels of nesting be suitable, because for me this type of structure make sense. The objects separated would be confusing for me, how do i read in and out notes for example, i just would not know howto even start approach howto read in and out something from such a hierarchy. 

function newTrack(m) { 
  track[m] = { 
    outport: [], 
    portname: [], 
    bank:[], 
    midichannel: [], 
    program: [], 
    trackname:"" , 
    midiMess: [], 
    //CONFIGURATION OF midiMess:[{time:0,data0:0,data1:0,data2:0}] 
  }; 
  return track; 
}

[toc] | [prev] | [next] | [standalone]

#36407

Den onsdag 24 april 2019 kl. 20:11:47 UTC+2 skrev jonas.t...@gmail.com:
> Den onsdag 24 april 2019 kl. 18:39:23 UTC+2 skrev John G Harris:
> > On Tue, 23 Apr 2019 23:50:46 -0700 (PDT), jonas.thornvall@gmail.com
> > wrote:
> > 
> >   <snip>
> > >Let us say i have a synth object, each synth have bank index and the banks have names, each bank have instrument index and the instruments have names.
> > 
> > Please stop sayint it's a bank index. It's a lot less confusing to say
> > it clearly : it's a list or sequence of banks. 
> > 
> > The same goes for the other things you've called an index.
> > 
> > 
> > >Now each instruments have notes with index and the notes have names. Maybe my attempt below is correct but it just feel so wrong? It somehow miss the depth aspect of multidimensional arrays?
> >   <snip>
> > 
> > So, what you've described can be summarised as :
> > 
> >   A synth object is
> >     a list of banks
> > 
> >   A bank is
> >     a name, and
> >     a list of instruments
> > 
> >   An instrument is
> >     a name, and
> >     a list of notes
> > 
> >   A note is
> >     a name
> > 
> > 
> > You can now see that you have four kinds of object. Each has two
> > properties :
> > 
> >   name, possibly null
> >   list, possibly null
> > 
> > A non-null name will be a string.
> > A non-null list will be an array.
> > 
> > 
> >   John
> 
> Here is my track object. As you can see it is easy to read out name port midichannel events, well one could quiestion why one would have all of them as arrays, but maybe there is bankchange or midichannelchange or programchange on the track.
> 
> But one thing is clear midi events midiMess[] is an array of sequential events that i push in "3 data bytes and a time".
> 
> Would not this kind of structure but with more levels of nesting be suitable, because for me this type of structure make sense. The objects separated would be confusing for me, how do i read in and out notes for example, i just would not know howto even start approach howto read in and out something from such a hierarchy. 
> 
> function newTrack(m) { 
>   track[m] = { 
>     outport: [], 
>     portname: [], 
>     bank:[], 
>     midichannel: [], 
>     program: [], 
>     trackname:"" , 
>     midiMess: [], 
>     //CONFIGURATION OF midiMess:[{time:0,data0:0,data1:0,data2:0}] 
>   }; 
>   return track; 
> }

Here is how i would work store data into my favoured structure of "made up" object

But how do i implement it, i do not understand the object syntax well enough to create it.

synth[i].synthname="Roland D50";

synth[i].bank[x].bankname="Base & Drum";

synth[i].bank[x].instrument[y].instname="Trombone";

synth[i].bank[x].instrument[y].note[z].notename="HiHat";

I am totally clueless how to implement this object though, but the way it accept data make sense to me?

Because such an object is possible to create or?

Syntax to create the object above please??????????????
function newCollection(m) { 
  synth[m] = { 
    synthname : "", 
    bank[]={ 
       bankname : "", 
       instr[]={ 
          instname :"", 
             note[]={ 
                 notenname : "", 
                         } 
       } 
    }           
  }; 
  return extSynth; 
} 

[toc] | [prev] | [next] | [standalone]

#36408

Den onsdag 24 april 2019 kl. 22:50:36 UTC+2 skrev jonas.t...@gmail.com:
> Den onsdag 24 april 2019 kl. 20:11:47 UTC+2 skrev jonas.t...@gmail.com:
> > Den onsdag 24 april 2019 kl. 18:39:23 UTC+2 skrev John G Harris:
> > > On Tue, 23 Apr 2019 23:50:46 -0700 (PDT), jonas.thornvall@gmail.com
> > > wrote:
> > > 
> > >   <snip>
> > > >Let us say i have a synth object, each synth have bank index and the banks have names, each bank have instrument index and the instruments have names.
> > > 
> > > Please stop sayint it's a bank index. It's a lot less confusing to say
> > > it clearly : it's a list or sequence of banks. 
> > > 
> > > The same goes for the other things you've called an index.
> > > 
> > > 
> > > >Now each instruments have notes with index and the notes have names. Maybe my attempt below is correct but it just feel so wrong? It somehow miss the depth aspect of multidimensional arrays?
> > >   <snip>
> > > 
> > > So, what you've described can be summarised as :
> > > 
> > >   A synth object is
> > >     a list of banks
> > > 
> > >   A bank is
> > >     a name, and
> > >     a list of instruments
> > > 
> > >   An instrument is
> > >     a name, and
> > >     a list of notes
> > > 
> > >   A note is
> > >     a name
> > > 
> > > 
> > > You can now see that you have four kinds of object. Each has two
> > > properties :
> > > 
> > >   name, possibly null
> > >   list, possibly null
> > > 
> > > A non-null name will be a string.
> > > A non-null list will be an array.
> > > 
> > > 
> > >   John
> > 
> > Here is my track object. As you can see it is easy to read out name port midichannel events, well one could quiestion why one would have all of them as arrays, but maybe there is bankchange or midichannelchange or programchange on the track.
> > 
> > But one thing is clear midi events midiMess[] is an array of sequential events that i push in "3 data bytes and a time".
> > 
> > Would not this kind of structure but with more levels of nesting be suitable, because for me this type of structure make sense. The objects separated would be confusing for me, how do i read in and out notes for example, i just would not know howto even start approach howto read in and out something from such a hierarchy. 
> > 
> > function newTrack(m) { 
> >   track[m] = { 
> >     outport: [], 
> >     portname: [], 
> >     bank:[], 
> >     midichannel: [], 
> >     program: [], 
> >     trackname:"" , 
> >     midiMess: [], 
> >     //CONFIGURATION OF midiMess:[{time:0,data0:0,data1:0,data2:0}] 
> >   }; 
> >   return track; 
> > }
> 
> Here is how i would work store data into my favoured structure of "made up" object
> 
> But how do i implement it, i do not understand the object syntax well enough to create it.
> 
> synth[i].synthname="Roland D50";
> 
> synth[i].bank[x].bankname="Base & Drum";
> 
> synth[i].bank[x].instrument[y].instname="Trombone";
> 
> synth[i].bank[x].instrument[y].note[z].notename="HiHat";
> 
> I am totally clueless how to implement this object though, but the way it accept data make sense to me?
> 
> Because such an object is possible to create or?
> 
> Syntax to create the object above please??????????????
> function newCollection(m) { 
>   synth[m] = { 
>     synthname : "", 
>     bank[]={ 
>        bankname : "", 
>        instr[]={ 
>           instname :"", 
>              note[]={ 
>                  notenname : "", 
>                          } 
>        } 
>     }           
>   }; 
>   return extSynth; 
> }

Well i looked enough into Javascript objects to understand they are flawed at some fundamental logical level. Better create some storage structure of ones own, like multidimensional arrays holding strings.

Well it may still may be an object but at least it make sense.

[toc] | [prev] | [next] | [standalone]

#36418

On Wed, 24 Apr 2019 11:11:32 -0700 (PDT), jonas.thornvall@gmail.com
wrote:

  <snip>
>Here is my track object. As you can see it is easy to read out name port midichannel events, well one could quiestion why one would have all of them as arrays, but maybe there is bankchange or midichannelchange or programchange on the track.
>
>But one thing is clear midi events midiMess[] is an array of sequential events that i push in "3 data bytes and a time".
>
>function newTrack(m) { 
>  track[m] = { 
>    outport: [], 
>    portname: [], 
>    bank:[], 
>    midichannel: [], 
>    program: [], 
>    trackname:"" , 
>    midiMess: [], 
>    //CONFIGURATION OF midiMess:[{time:0,data0:0,data1:0,data2:0}] 
>  }; 
>  return track; 
>}

It would be tidier to write :

  function newTrack()
    { 
      var track = 
        { 
          trackname:"" , 
          outport: [], 
          portname: [], 
          bank:[], 
          midichannel: [], 
          program: [], 
          midiMess: [], 
            //CONFIGURATION OF midiMess:
            //  [{time:0,data0:0,data1:0,data2:0}] 
        }; 
        
      return track; 
    }

To use this function you would do
  track[m] = newTrack();


Also it would be tidier to add the function :

  function newMidiMess()
    {
      var midiMess =
        {
          time:  0,
          data0: 0,
          data1: 0,
          data2: 0
        };
        
      return midiMess;
    }


>Would not this kind of structure but with more levels of nesting be suitable, because for me this type of structure make sense. The objects separated would be confusing for me, how do i read in and out notes for example, i just would not know howto even start approach howto read in and out something from such a hierarchy. 

The implementation can be a tree structure, built from the objects
created by functions that are something like this :
    
  function newSynth()
    {
      var synth =
        {
          name: "",
          banks: []  // Array of bank objects
        };
        
      return synth;
    }
    
  function newBank()
    {
      var bank =
        {
          name: "",
          instruments: []  // Array of instrument objects
        };
        
      return bank;
    }
    
  function newInstrument()
    {
      var instrument =
        {
          name: "",
          notes: []  // Array of note objects
        };
        
      return instrument;
    }
    
  function newNote()
    {
      var note =
        {
          name: ""
        };
        
      return note;
    }


  John

[toc] | [prev] | [standalone]

Back to top | Article view | comp.lang.javascript

csiph-web