Search and sort customers from JSON file
Your code is really hard to read as noted by @Sumurai8.  That is the first thing that jumps out at you, which is bad.
Consider placing all your javascript code within $(document).ready() handler.  There is no reason any of this code needs to operate in global scope.
Cache your JSON data. There seems to be no reason to continually call getJSON() if you are calling a static file anyway.
Don't keep re-querying the DOM.  If you ever have a case where a selector is going to be used more than once during code operations on a page, you should consider storing the jQuery resource in a variable, so as to minimize queries against the DOM. Of course there is is a trade-off of increased memory consumption for this performance gain, but for most applications, that should not be a concern. Particularly good candidates for this approach are those jQuery selectors that happen within event-handler callbacks that get called repeatedly.
Your filtering condition in the getJSON() success handler does not seem appropriate to me.  I think perhaps the JSON data structure is bad.  Why would you need to iterate over the whole array of searchable objects to figure out which ones meets the keyword criteria?  Why are you then only working with the first returned result that meets this criteria? The data structure should support your desired lookup case. I would consider building a key-based data structure where you combine the keys from the object id and name values and references to applicable objects against that key.  Or alternately have two different data structures - one indexed by id and one indexed by name and make two lookups in response to each find() activity.  Either approach would give operational complexity of O(1) in that the find() operation would take a (relatively) fixed amount of time to execute regardless of the size of the data set you are searching against (once data is loaded).  Your current approach is O(n), such that operation takes linearly longer to complete as the size of your dataset being searched increases. There is no reason at all to make this method perform so poorly.  Between your lack of caching of the data structure and linear complexity, you have a really poorly performing find() function which does all of the following EVERY time the function is called:


You re-load JSON (perhaps via HTTP request, perhaps just from browser cache if lucky) - a costly operation where you read a potentially large string into memory.
You then deserialize that JSON into a javascript array of objects (again a costly operation for potentially large string)
You then iterate every member of that javascript to perform lookup.



You should be striving for a solution where:


Either prior to or with first request to find() you retrieve the JSON data source(s), deserialize them and store them in named javascript variables.
You have a data structure that allows O(1) lookup against the data set.
find() operation uses the stored data structure in javascript to operate against.