Best way to store this data in a variable?

Some quick background info: I'm coding up a site which matches books to the classes they're required for.

I have two pieces of data that I need to represent in my code-- which books go with whic开发者_运维问答h classes, and the data (titles, authors, pricing, etc.) on these books.

Currently I represent this all with two arrays: $classArray, and $Books_data.

The advantage of this approach over a one-variable approach is that I don't repeat myself-- if a Book is required multiple times for different classes, only the ISBN needs to be stored in the $classArray and I can store the data in the $Books_array. This advantage is especially poignant because I have to query the pricing data from API's on the fly. If I only had a $classBooksArray, I'd have to loop the query responses into a big array, repeating myself (seemingly) unnecessarily.

The disadvantage of this approach is that these variables follow each other almost everywhere like Siamese twins. Nearly every function that needs one, needs the other. And my coding spidey sense tells me it might be unnecessary.

So, what would be the best way to store this data? Two arrays, one array, or some other approach I haven't mentioned (e.g. passing by reference).

Why not an associative which has two keys - one pointing to an array of classes, one to store Books
data?

$allData = array("classes" => &$classArray, "books" => &$Books_data);

That way you're only passing around 1 variable (less clutter) but retain all the benefits of separate data stores for books and classes.

Though, to be honest, if it's just TWO sets of data, so IMHO your spidey sense is wrong - passing both as separate parameters is perfectly fine. Once you get into a set of siamise sextuplet variables, then the above approach starts to actually bring benefits.

A multidimensional array.

$collection = array(
    'classes' => array( /* Contents of $classArray */),
    'books' => array( /* Contents of $Books_data */)
);

function some_function($collection) {
    // looping over books
    foreach ($collection['books'] as $book) {
        // yadda yadda
    }
}

Or better yet a class:

/* Define */
class Collection {
    private $books;
    private $classes;
    public function __construct($classes = array(), $books = array()) {
        $this->books = $books;
        $this->classes = $classes;
    }
    public function addBook($book) {
        $this->books[] = $book;
    }
    public function addClass($class) {
        $this->classes[] = $class;
    }
    public function get_classes() {
        return $this->classes;
    }
    public function get_books() {
        return $this->books;
    }
}
function some_function(Collection $col) {
    // looping over books
    foreach ($col->get_books as $book) {
        // yadda yadda
    }
}

/* Usage */
$collection = new Collection(); // you also could pass classes and books in the
                                // constructor.
$collection->addBook($book);
somefunction($collection);

If your datas were a database, your current proposal being a normal form would be canonical. The two variables would just become tables and ISBN a foreign key to books table (with a third table as a class has several books). I would probably stick with the current implementation as it will be very easy to transform to database when that will be necessary (and it usually happens faster than expected).

EDIT: a comment, say it is already in a database... what I do not understand is why you would want to store a full database in memory instead of just keeping what is necessary for the current task.

Let's be OO and put the arrays into an object. Define a class with those properties, load it up, and call its methods. Or, if you must have other functions operating with the object's data, pass the instance around. Disallow direct access to the data, but provide methods for extracting the salient info.

class book_class_association {

   protected $books_to_classes = array();
   protected $classes_to_books = array();

   function __construct() {
      $this->books_to_classes = array(
         'mathbook1' => array('math'),
         'mathbook2' => array('math'),
      );
      $this->classes_to_books = array(
         'math' => array('mathbook1', 'mathbook2'),
      );
   }

   function classes_for_book( $class_name ) {
      return $this->books_to_classes[$class_name];
   }

   function books_for_class( $class_name ) {
      return $this->classes_to_books[$class_name];
   }

}

Is there a reason you are not storing this data in a database and then querying the database? It is a many to many relationship, and you would need 3 tables - class , book, and class_book_intersection.

So for example, you ui could have "select class" from a list, where the list is derived from the rows in class.

Then if the class id selected is 123. The query would then be something like:

Select  book.title,  book.cost
 from book 
inner join class_book_intersection
  on 
class_book_intersection.classid = 123 and  
class_book_intersection.bookid = book.bookid