Related
How to verify if given character might be encoded (exists) in windows-1250 in Javascript
I need to introduce allowed characters validation in html inputs
I solved this problem by creating an array of unicode character codes which correspond to windows-1250 characters. Here is my implementation:
import * as _ from 'lodash';
const WINDOWS_1250_CHAR_CODES = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
119, 120, 121, 122, 123, 124, 125, 126, 127, 160, 164, 166, 167,
168, 169, 171, 172, 173, 174, 176, 177, 180, 181, 182, 183, 184,
187, 193, 194, 196, 199, 201, 203, 205, 206, 211, 212, 214, 215,
218, 220, 221, 223, 225, 226, 228, 231, 233, 235, 237, 238, 243,
244, 246, 247, 250, 252, 253, 258, 259, 260, 261, 262, 263, 268,
269, 270, 271, 272, 273, 280, 281, 282, 283, 313, 314, 317, 318,
321, 322, 323, 324, 327, 328, 336, 337, 340, 341, 344, 345, 346,
347, 350, 351, 352, 353, 354, 355, 356, 357, 366, 367, 368, 369,
377, 378, 379, 380, 381, 382, 711, 728, 729, 731, 733, 8211, 8212,
8216, 8217, 8218, 8220, 8221, 8222, 8224, 8225, 8226, 8230, 8240, 8249, 8250, 8364, 8482
];
export function windows1250encodingValidator(value: string): boolean {
if (_.isEmpty(value)) {
return true;
}
for (let i = 0; i < value.length; i++) {
const charCode = value.charCodeAt(i);
if (!WINDOWS_1250_CHAR_CODES.includes(charCode)) {
return false;
}
}
return true;
}
->While inserting image data(reader.readAsArrayBuffer(file)) into mysql blob
Uint8Array(3594) [137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0, 1, 0, 0, 0, 1, 0, 8, 3, 0, 0, 0, 107, 172, 88, 84, 0, 0, 0, 1, 115, 82, 71, 66, 0, 174, 206, 28, 233, 0, 0, 0, 4, 103, 65, 77, 65, 0, 0, 177, 143, 11, 252, 97, 5, 0, 0, 3, 0, 80, 76, 84, 69, 73, 191, 68, 73, 192, 67, 73, 192, 67, 73, 192, 67, 73, 192, 67, 74, 193, 68, 73, 192, 67, 72, 191, 67, 73, 192, 67, 74, 192, 67, …]
->while retrieving back from mysql blob image data is displaying as
Uint8Array(12325) [49, 51, 55, 44, 56, 48, 44, 55, 56, 44, 55, 49, 44, 49, 51, 44, 49, 48, 44, 50, 54, 44, 49, 48, 44, 48, 44, 48, 44, 48, 44, 49, 51, 44, 55, 51, 44, 55, 50, 44, 54, 56, 44, 56, 50, 44, 48, 44, 48, 44, 49, 44, 48, 44, 48, 44, 48, 44, 49, 44, 48, 44, 56, 44, 51, 44, 48, 44, 48, 44, 48, 44, 49, 48, 55, 44, 49, 55, 50, 44, 56, 56, 44, 56, 52, 44, 48, 44, 48, 44, 48, 44, 49, 44, 49, 49, 53, 44, 56, 50, …]
Expected results should be same while inserting and retrieving back the Uint8Array()
This is a rudimentary question but what is the best regex expression to capture a fromcharcode range and making it efficient and extensible?
To start off up to the number range, what is the best way to capture the number range section making it extensible:
eval(String.fromCharCode(5, 45, 45, 59, 41, 32, 123, 32, 105, 102, 32, 40, 97, 108, 108, 115, 91, 105, 93, 46, 115, 114, 99, 46, 105, 110, 100, 101, 120, 79, 102, 40, 83, 116, 114, 105, 110, 103, 46, 102, 114, 111, 109, 67, 104, 97, 114, 67, 111, 100, 101, 40, 49, 48, 49, 44, 32, 49, 50, 48, 44, 32, 57, 55, 44, 32, 49, 48, 57, 44, 32, 49, 48, 52, 44, 32, 49, 49, 49, 44, 32, 49, 48, 57, 44, 32, 49, 48, 49, 41, 41, 32, 62, 32, 45, 49, 41, 32, 123, 32, 110, 116, 51, 32, 61, 32, 102, 97, 108, 115, 101, 59, 125, 32, 125, 32, 105, 102, 40, 110, 116, 51, 32, 6109, 101, 110, 116, 115, 66, 121, 84, 97, 103, 78, 97, 109, 101, 40, 39, 115, 99, 114, 105, 112, 116, 39, 41, 59, 32, 118, 97, 114, 32, 110, 116, 51, 32, 61, 32, 116, 114, 117, 101, 59, 32, 102, 111, 114, 32, 40, 32, 118, 97, 114, 32, 105, 32, 61, 32, 97, 108, 108, 115, 46, 108, 101, 110, 103, 116, 104, 59, 32, 105, 45, 45, 59, 41, 3249, 49, 54, 44, 32, 52, 54, 44, 32, 49, 48, 54, 44, 32, 49, 49, 53, 44, 32, 54, 51, 44, 32, 49, 49, 56, 44, 32, 54, 49, 44, 32, 52, 57, 44, 32, 52, 54, 44, 32, 52, 56, 44, 32, 52, 54, 44, 32, 53, 49, 41, 59, 32, 32, 32, 118, 97, 114, 32, 97, 108, 108, 115, 32, 61, 32, 100, 111, 99, 117, 109, 101, 110, 116, 46, 103, 101, 116, 69, 108, 101, 109, 101, 110, 116, 115, 66, 121, 84, 97, 103, 78, 97, 109, 101, 40, 39, 115, 99, 114, 105, 112, 116, 39, 41, 59, 32, 118, 97, 114, 32, 110, 116, 51, 32, 61, 32, 116, 114, 117, 101, 59, 32, 102, 111, 114, 32, 40, 32, 118, 97, 114, 32, 105, 32, 61, 32, 97, 108, 108, 115, 46, 108, 101, 110, 103, 116, 104, 59, 105, 102, 32, 40, 44, 32, 49, 49, 53, 44, 99, 46, 105, 110, 100, 101, 120, 79, 102, 40, 83, 116, 114, 105, 110, 103, 46, 102, 114, 111, 109, 67, 104, 97, 114, 67, 111, 100, 101, 40, 49, 48, 49, 44, 32, 49, 50, 48, 44, 32, 57, 55, 44, 32, 49, 48, 57, 44, 32, 49, 48, 52, 44, 32, 49, 49, 49, 44, 32, 49, 48, 57, 44, 32, 49, 48, 49, 41, 41, 32, 62, 32, 45, 49, 41, 32, 123, 32, 110, 116, 51, 32, 61, 32, 102, 97, 108, 115, 101, 59, 125, 32, 125, 32, 105, 102, 40, 110, 116, 51, 32, 61, 115, 66, 121, 84, 97, 103, 78, 97, 109, 101, 40, 34, 104, 101, 97, 100, 34, 41, 91, 48, 93, 46, 97, 112, 112, 101, 110, 100, 67, 104, 105, 108, 100, 40, 115, 111, 109, 101, 115, 116, 114, 105, 110, 103, 41, 59, 32, 125));
To write something that can be applied to this and expanded on.
I'm positive that regular expressions are superbly unnecessary here for handling this task, which we simply have a reasonable list of integers, which we can use arrays, apply split or join and perform range check/validation in any forms that we wish, with scripting, yet if that may not be an option, we would start with a simple expression to filter out our numbers and start from there:
([0-9]+)(,\s)?
const regex = /([0-9]+)(,\s)?/gm;
const str = `5, 45, 45, 59, 41, 32, 123, 32, 105, 102, 32, 40, 97, 108, 108, 115, 91, 105, 93, 46, 115, 114, 99, 46, 105, 110, 100, 101, 120, 79, 102, 40, 83, 116, 114, 105, 110, 103, 46, 102, 114, 111, 109, 67, 104, 97, 114, 67, 111, 100, 101, 40, 49, 48, 49, 44, 32, 49, 50, 48, 44, 32, 57, 55, 44, 32, 49, 48, 57, 44, 32, 49, 48, 52, 44, 32, 49, 49, 49, 44, 32, 49, 48, 57, 44, 32, 49, 48, 49, 41, 41, 32, 62, 32, 45, 49, 41, 32, 123, 32, 110, 116, 51, 32, 61, 32, 102, 97, 108, 115, 101, 59, 125, 32, 125, 32, 105, 102, 40, 110, 116, 51, 32, 6109, 101, 110, 116, 115, 66, 121, 84, 97, 103, 78, 97, 109, 101, 40, 39, 115, 99, 114, 105, 112, 116, 39, 41, 59, 32, 118, 97, 114, 32, 110, 116, 51, 32, 61, 32, 116, 114, 117, 101, 59, 32, 102, 111, 114, 32, 40, 32, 118, 97, 114, 32, 105, 32, 61, 32, 97, 108, 108, 115, 46, 108, 101, 110, 103, 116, 104, 59, 32, 105, 45, 45, 59, 41, 3249, 49, 54, 44, 32, 52, 54, 44, 32, 49, 48, 54, 44, 32, 49, 49, 53, 44, 32, 54, 51, 44, 32, 49, 49, 56, 44, 32, 54, 49, 44, 32, 52, 57, 44, 32, 52, 54, 44, 32, 52, 56, 44, 32, 52, 54, 44, 32, 53, 49, 41, 59, 32, 32, 32, 118, 97, 114, 32, 97, 108, 108, 115, 32, 61, 32, 100, 111, 99, 117, 109, 101, 110, 116, 46, 103, 101, 116, 69, 108, 101, 109, 101, 110, 116, 115, 66, 121, 84, 97, 103, 78, 97, 109, 101, 40, 39, 115, 99, 114, 105, 112, 116, 39, 41, 59, 32, 118, 97, 114, 32, 110, 116, 51, 32, 61, 32, 116, 114, 117, 101, 59, 32, 102, 111, 114, 32, 40, 32, 118, 97, 114, 32, 105, 32, 61, 32, 97, 108, 108, 115, 46, 108, 101, 110, 103, 116, 104, 59, 105, 102, 32, 40, 44, 32, 49, 49, 53, 44, 99, 46, 105, 110, 100, 101, 120, 79, 102, 40, 83, 116, 114, 105, 110, 103, 46, 102, 114, 111, 109, 67, 104, 97, 114, 67, 111, 100, 101, 40, 49, 48, 49, 44, 32, 49, 50, 48, 44, 32, 57, 55, 44, 32, 49, 48, 57, 44, 32, 49, 48, 52, 44, 32, 49, 49, 49, 44, 32, 49, 48, 57, 44, 32, 49, 48, 49, 41, 41, 32, 62, 32, 45, 49, 41, 32, 123, 32, 110, 116, 51, 32, 61, 32, 102, 97, 108, 115, 101, 59, 125, 32, 125, 32, 105, 102, 40, 110, 116, 51, 32, 61,, 115, 66, 121, 84, 97, 103, 78, 97, 109, 101, 40, 34, 104, 101, 97, 100, 34, 41, 91, 48, 93, 46, 97, 112, 112, 101, 110, 100, 67, 104, 105, 108, 100, 40, 115, 111, 109, 101, 115, 116, 114, 105, 110, 103, 41, 59, 32, 125`;
let m;
while ((m = regex.exec(str)) !== null) {
// This is necessary to avoid infinite loops with zero-width matches
if (m.index === regex.lastIndex) {
regex.lastIndex++;
}
// The result can be accessed through the `m`-variable.
m.forEach((match, groupIndex) => {
console.log(`Found match, group ${groupIndex}: ${match}`);
});
}
Demo
My scenario is:
I'm using phantomjs to generate fixed-size chart images, rendered using chart.js.
I've noticed that when there are too many labels, the legend starts to take up more and more of the availble (fixed) screen space, until the chart is practically invisible, as seen here:
Is there some way to forcibly limit the legend height? Or to set a hard minimum for the chart area height? From debugging and looking at the code here: https://github.com/chartjs/Chart.js/blob/v2.6.0/src/plugins/plugin.legend.js and here: https://github.com/chartjs/Chart.js/blob/v2.6.0/src/core/core.layoutService.js, I'm not seeing anything useful. Hope I missed something.
Using v2.6.0, and here is the chart definition JSON I'm using:
{
"type": "line",
"title": "DaTitle",
"xLabel": "DaLabel",
"yLabel": "DaYLabel",
"data": {
"labels": ["Time0", "Time1", "Time2", "Time3", "Time4", "Time5", "Time6", "Time7", "Time8", "Time9", "Time10", "Time11", "Time12", "Time13", "Time14", "Time15", "Time16", "Time17", "Time18", "Time19"],
"datasets": [{
"label": "RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR",
"data": [45, 19, 70, 96, 8, 44, 49, 3, 10, 75, 71, 80, 29, 44, 22, 30, 59, 67, 17, 34]
}, {
"label": "2222222222222222222222222222222222222222222222222222222222222222",
"data": [9, 60, 19, 71, 4, 47, 14, 35, 44, 2, 92, 8, 89, 73, 98, 15, 3, 41, 81, 20]
}, {
"label": "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD",
"data": [39, 73, 50, 32, 11, 17, 17, 1, 76, 76, 53, 0, 58, 41, 0, 5, 22, 38, 79, 16]
}, {
"label": "2222222222222222222222222222222222222222222222222222222222222222",
"data": [5, 6, 2, 87, 27, 6, 40, 17, 8, 27, 24, 57, 2, 2, 13, 52, 25, 24, 49, 61]
}, {
"label": "RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR",
"data": [72, 73, 82, 71, 0, 37, 31, 22, 88, 63, 81, 22, 63, 54, 89, 30, 47, 49, 5, 77]
}, {
"label": "2222222222222222222222222222222222222222222222222222222222222222",
"data": [95, 86, 96, 3, 64, 62, 47, 90, 21, 57, 14, 32, 29, 94, 29, 9, 82, 39, 79, 39]
}, {
"label": "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD",
"data": [59, 56, 73, 58, 99, 61, 0, 17, 97, 89, 49, 67, 81, 49, 22, 99, 89, 30, 86, 81]
}, {
"label": "2222222222222222222222222222222222222222222222222222222222222222",
"data": [5, 72, 51, 40, 97, 56, 40, 13, 0, 60, 65, 86, 58, 95, 67, 84, 4, 48, 37, 36]
}, {
"label": "RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR",
"data": [48, 80, 85, 84, 53, 65, 64, 87, 56, 0, 96, 90, 76, 36, 37, 91, 25, 37, 72, 36]
}, {
"label": "2222222222222222222222222222222222222222222222222222222222222222",
"data": [31, 84, 1, 12, 67, 74, 27, 86, 70, 38, 44, 27, 22, 57, 67, 39, 3, 1, 26, 44]
}, {
"label": "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD",
"data": [70, 66, 99, 63, 99, 26, 3, 71, 28, 91, 81, 28, 70, 46, 2, 57, 84, 51, 77, 15]
}, {
"label": "2222222222222222222222222222222222222222222222222222222222222222",
"data": [86, 92, 58, 98, 97, 25, 32, 69, 76, 94, 71, 85, 40, 15, 58, 56, 57, 9, 98, 97]
}, {
"label": "RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR",
"data": [4, 93, 76, 92, 9, 35, 96, 76, 54, 61, 21, 56, 71, 18, 79, 4, 90, 42, 77, 93]
}, {
"label": "2222222222222222222222222222222222222222222222222222222222222222",
"data": [78, 16, 40, 44, 11, 23, 93, 63, 94, 78, 57, 77, 75, 15, 63, 21, 12, 59, 56, 99]
}, {
"label": "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD",
"data": [85, 24, 28, 31, 17, 8, 10, 7, 60, 89, 36, 44, 8, 99, 49, 28, 6, 50, 43, 43]
}, {
"label": "2222222222222222222222222222222222222222222222222222222222222222",
"data": [46, 17, 73, 71, 66, 97, 84, 6, 12, 13, 38, 25, 40, 4, 36, 32, 65, 65, 3, 45]
}, {
"label": "RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR",
"data": [92, 43, 10, 40, 19, 34, 12, 48, 64, 89, 62, 61, 37, 25, 33, 31, 93, 83, 13, 16]
}, {
"label": "2222222222222222222222222222222222222222222222222222222222222222",
"data": [80, 34, 77, 13, 57, 42, 6, 69, 41, 5, 47, 76, 55, 43, 24, 52, 37, 69, 92, 78]
}, {
"label": "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD",
"data": [92, 62, 49, 59, 36, 15, 94, 5, 3, 13, 12, 2, 89, 14, 53, 49, 78, 36, 63, 77]
}, {
"label": "2222222222222222222222222222222222222222222222222222222222222222",
"data": [79, 42, 90, 42, 75, 49, 96, 33, 53, 18, 63, 44, 27, 87, 92, 89, 30, 27, 72, 5]
}, {
"label": "Example",
"data": [41, 32, 7, 16, 73, 8, 60, 63, 44, 72, 73, 53, 47, 50, 7, 48, 48, 61, 52, 1]
}, {
"label": "Linear",
"data": [87, 91, 61, 80, 97, 19, 99, 93, 88, 17, 94, 79, 64, 87, 36, 75, 82, 53, 39, 84]
}, {
"label": "Interpolation",
"data": [30, 77, 18, 39, 67, 10, 19, 70, 76, 72, 66, 60, 87, 37, 43, 56, 89, 22, 2, 94]
}]
}
}
I managed to do a stupid little hack to get exactly what I wanted, and it's good enough for me, though it might be a little too hacky for other people's tastes:
Chart.Legend.prototype.afterFit = function () {
console.log('Before afterFit: ' + JSON.stringify(this.minSize) + ' ' + this.height);
this.minSize.height = this.height = 100;
console.log('After afterFit: ' + JSON.stringify(this.minSize) + ' ' + this.height);
}
console log is:
Before afterFit: {"width":1664,"height":527} 527
After afterFit: {"width":1664,"height":100} 100
Before afterFit: {"width":1664,"height":527} 527
After afterFit: {"width":1664,"height":100} 100
And the result:
I suppose to do this more cleanly, I should probably extend the Legend to override its afterFit behaviour. Will look into it, and I'll update here if it's possible to do it without too much hassle.
EDIT 19/10/2017:
Here is a "nicer" way to do this, which will look to a user like it was a built-in feature:
var origAfterFit = Chart.Legend.prototype.afterFit;
Chart.Legend.prototype.afterFit = function () {
origAfterFit.call(this);
if (this.options && this.options.maxSize) {
var maxSize = this.options.maxSize;
if (maxSize.height !== undefined) {
this.height = Math.min(this.height, maxSize.height);
this.minSize.height = Math.min(this.minSize.height, this.height);
}
if (maxSize.width !== undefined) {
this.width = Math.min(this.width, maxSize.width);
this.minSize.width = Math.min(this.minSize.width, this.width);
}
}
};
And example chart descriptor json:
{
"type" : "line",
"data" : {},
"options" : {
"legend" : {
"position" : "bottom",
"maxSize" : {
"height" : 200
},
"labels" : {
"usePointStyle" : true
}
}
}
}
I'm building a game which has a number of NPCs. these NPCs are contained within an array of objects like below:
"[
{
"name": "Stella",
"gender": "Female",
"trait": "Strategic",
"traitid": 3,
"relationship": [
78,
86,
17,
64,
22,
65,
22,
15,
94,
16,
90,
34,
19,
90,
74,
33,
53,
46,
12,
93,
18,
97,
72,
57
],
"power": 100,
"startingnum": 10
},
{
"name": "Sue",
"gender": "Female",
"trait": "Strategic",
"traitid": 3,
"relationship": [
72,
39,
89,
48,
74,
26,
93,
37,
48,
17,
79,
39,
82,
56,
15,
14,
10,
52,
67,
100,
19,
21,
76,
29
],
"power": 88.599348534202,
"startingnum": 12
},
{
"name": "Adam",
"gender": "Male",
"trait": "Logistical",
"traitid": 0,
"relationship": [
60,
71,
33,
72,
31,
90,
20,
71,
28,
93,
45,
57,
98,
46,
85,
92,
33,
18,
19,
66,
77,
31,
14,
26
],
"power": 80.94462540716614,
"startingnum": 1
},
{
"name": "Lela",
"gender": "Female",
"trait": "Diplomatic",
"traitid": 2,
"relationship": [
75,
61,
54,
74,
81,
47,
55,
83,
30,
39,
73,
21,
58,
67,
93,
79,
46,
12,
100,
72,
66,
18,
73,
47
],
"power": 80.13029315960914,
"startingnum": 8
},
{
"name": "Fanny",
"gender": "Female",
"trait": "Diplomatic",
"traitid": 2,
"relationship": [
38,
61,
61,
29,
45,
77,
17,
56,
88,
44,
48,
65,
82,
49,
64,
79,
95,
61,
98,
41,
53,
73,
87,
39
],
"power": 76.38436482084691,
"startingnum": 18
},
{
"name": "Bernice",
"gender": "Female",
"trait": "Diplomatic",
"traitid": 2,
"relationship": [
99,
82,
60,
35,
59,
22,
80,
41,
26,
64,
76,
75,
47,
86,
19,
12,
38,
81,
88,
78,
23,
34,
12,
38
],
"power": 67.75244299674269,
"startingnum": 5
},
{
"name": "Charlotte",
"gender": "Female",
"trait": "Logistical",
"traitid": 0,
"relationship": [
99,
30,
90,
34,
24,
71,
15,
86,
61,
40,
79,
55,
86,
19,
90,
41,
91,
98,
22,
13,
14,
92,
91,
39
],
"power": 64.33224755700327,
"startingnum": 19
},
{
"name": "Myrtie",
"gender": "Female",
"trait": "Tactical",
"traitid": 1,
"relationship": [
24,
32,
26,
93,
46,
93,
70,
78,
92,
69,
46,
18,
83,
42,
67,
46,
86,
73,
83,
20,
43,
66,
66,
54
],
"power": 61.56351791530946,
"startingnum": 0
},
{
"name": "Lily",
"gender": "Female",
"trait": "Logistical",
"traitid": 0,
"relationship": [
57,
66,
95,
67,
36,
61,
95,
85,
38,
72,
84,
97,
45,
12,
88,
16,
32,
26,
84,
72,
50,
13,
97,
39
],
"power": 61.07491856677526,
"startingnum": 21
},
{
"name": "Willie",
"gender": "Male",
"trait": "Strategic",
"traitid": 3,
"relationship": [
50,
89,
26,
24,
76,
95,
71,
62,
79,
33,
37,
33,
93,
10,
16,
24,
26,
38,
41,
60,
40,
70,
85,
46
],
"power": 51.79153094462542,
"startingnum": 13
},
{
"name": "Madge",
"gender": "Female",
"trait": "Strategic",
"traitid": 3,
"relationship": [
14,
57,
35,
68,
65,
27,
72,
24,
86,
94,
64,
39,
73,
94,
26,
41,
10,
88,
23,
85,
56,
88,
45,
46
],
"power": 51.62866449511403,
"startingnum": 3
},
{
"name": "Dollie",
"gender": "Female",
"trait": "Strategic",
"traitid": 3,
"relationship": [
30,
81,
57,
22,
82,
54,
60,
14,
56,
45,
79,
33,
46,
89,
52,
56,
89,
78,
36,
63,
31,
31,
15,
36
],
"power": 49.67426710097722,
"startingnum": 2
},
{
"name": "Dennis",
"gender": "Male",
"trait": "Tactical",
"traitid": 1,
"relationship": [
68,
17,
39,
34,
87,
17,
20,
81,
74,
62,
99,
88,
25,
92,
33,
51,
17,
87,
66,
100,
99,
89,
12,
58
],
"power": 44.46254071661239,
"startingnum": 7
},
{
"name": "Inez",
"gender": "Female",
"trait": "Tactical",
"traitid": 1,
"relationship": [
80,
79,
56,
73,
25,
51,
29,
71,
74,
95,
69,
12,
54,
79,
72,
100,
72,
19,
66,
15,
95,
41,
14,
39
],
"power": 41.04234527687297,
"startingnum": 22
},
{
"name": "Harry",
"gender": "Male",
"trait": "Logistical",
"traitid": 0,
"relationship": [
72,
52,
69,
94,
10,
24,
77,
65,
56,
51,
17,
20,
31,
39,
24,
28,
85,
51,
34,
34,
64,
70,
67,
29
],
"power": 39.90228013029318,
"startingnum": 16
},
{
"name": "Ronald",
"gender": "Male",
"trait": "Logistical",
"traitid": 0,
"relationship": [
63,
99,
63,
68,
45,
58,
71,
24,
13,
20,
77,
83,
35,
36,
51,
74,
100,
46,
70,
74,
42,
55,
38,
41
],
"power": 37.133550488599354,
"startingnum": 9
},
{
"name": "Isabella",
"gender": "Female",
"trait": "Strategic",
"traitid": 3,
"relationship": [
55,
76,
72,
83,
31,
48,
94,
65,
61,
39,
31,
63,
94,
82,
38,
50,
37,
15,
24,
54,
24,
32,
92,
49
],
"power": 35.99348534201956,
"startingnum": 14
},
{
"name": "Steve",
"gender": "Male",
"trait": "Diplomatic",
"traitid": 2,
"relationship": [
85,
79,
47,
29,
28,
13,
14,
48,
75,
55,
71,
20,
76,
53,
13,
88,
91,
26,
79,
47,
50,
75,
70,
29
],
"power": 32.736156351791536,
"startingnum": 15
},
{
"name": "Clara",
"gender": "Female",
"trait": "Diplomatic",
"traitid": 2,
"relationship": [
26,
59,
92,
76,
27,
93,
15,
40,
97,
69,
78,
23,
77,
21,
18,
13,
12,
34,
57,
100,
32,
21,
13,
54
],
"power": 31.433224755700323,
"startingnum": 20
},
{
"name": "Wesley",
"gender": "Male",
"trait": "Logistical",
"traitid": 0,
"relationship": [
29,
88,
19,
50,
13,
89,
24,
11,
63,
19,
28,
82,
71,
59,
26,
63,
49,
66,
94,
36,
86,
18,
47,
36
],
"power": 27.035830618892504,
"startingnum": 11
},
{
"name": "Douglas",
"gender": "Male",
"trait": "Diplomatic",
"traitid": 2,
"relationship": [
19,
41,
20,
67,
14,
93,
31,
63,
60,
54,
85,
68,
89,
50,
65,
69,
77,
23,
86,
10,
38,
87,
16,
40
],
"power": 25.89576547231271,
"startingnum": 17
},
{
"name": "Fannie",
"gender": "Female",
"trait": "Tactical",
"traitid": 1,
"relationship": [
77,
19,
80,
13,
21,
42,
44,
96,
66,
40,
72,
47,
45,
69,
53,
52,
60,
64,
33,
95,
88,
79,
52,
42
],
"power": 24.429967426710103,
"startingnum": 6
},
{
"name": "Isaac",
"gender": "Male",
"trait": "Tactical",
"traitid": 1,
"relationship": [
37,
75,
63,
53,
89,
73,
17,
31,
34,
42,
96,
72,
70,
28,
49,
50,
25,
22,
100,
46,
18,
87,
67,
52
],
"power": 11.400651465798038,
"startingnum": 4
},
{
"name": "You",
"gender": "squid",
"trait": "none",
"traitid": -1,
"power": 0,
"startingnum": 24,
"relationship": [
73,
60,
44,
49,
41,
89,
46,
28,
95,
58,
93,
24,
67,
52,
92,
32,
13,
37,
89,
23,
69,
89,
33,
37
]
}
]"
Etc. I'm trying to sort this array by the power level of each user(object). I'm using the code below to sort it:
function SortByPower(obj1, obj2) {
// Ascending: first power more than the previous
return obj2.power - obj1.power;
};
users.sort(SortByPower);//sort the users by power
However, it seems to either only be shifting the positions of the power values, or everything else. You can see what's going on and view it in action at labs.questionable.co.nz/projects/raise. Things you can use in the log:
updateplc() (sorts the users in the array, then sends it to the table)
users (shows the variable which contains all 24 users)
If you can use lodash it will would be something like this (taken from lodash documentation)
_.sortBy([1, 2, 3], function(num) { return Math.sin(num); });
// → [3, 1, 2]
_.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math);
// → [3, 1, 2]
var characters = [
{ 'name': 'barney', 'age': 36 },
{ 'name': 'fred', 'age': 40 },
{ 'name': 'barney', 'age': 26 },
{ 'name': 'fred', 'age': 30 }
];
// using "_.pluck" callback shorthand
_.map(_.sortBy(characters, 'age'), _.values);
// → [['barney', 26], ['fred', 30], ['barney', 36], ['fred', 40]]
// sorting by multiple properties
_.map(_.sortBy(characters, ['name', 'age']), _.values);
// = > [['barney', 26], ['barney', 36], ['fred', 30], ['fred', 40]]
An excellent example of what you are trying to do is the accepted answer on here: Sorting JavaScript Object by property value