Почему в JavaScript не изменили простую и очевидную штуку?
 

indexOf - это де-факто firstIndexOf. Почему его не переименовали или по крайней мере не добавили метод firstIndexOf, чтобы не вводить в заблуждение новичков?

Потому что неочевиден только lastIndexOf. А просто indexOf очевиден в любой системе логики.
Если вы шизофреник, то это ваши проблемы.

Идиотское и немотивированное (зачем?) оскорбление проигнорирую, а по сути скажу то, что наличие метода firstIndexOf подсказывало бы новичкам, что существует и метод lastIndexOf, наличие которого зачастую является сюрпризом. Плюс наличие такой логики могло бы привести, к примеру, к появлению метода middleIndexOf.

Для краткости. Javascript передаётся по сети в нескомпилированном виде, простым текстом. Много, очень много раз передаётся.

То же самое. Плюс ненужное дублирование.

Это задача туториалов и учебников.

Если понадобится, то появится. Не вижу тут никаких препятствий.

Почему такую штуку не ввели?

Array.prototype.last = function(){
    return this[this.length-1];
}

Или вообще отрицательные индексы как в Питоне. В splice они есть, а в обычной индексации массива - нет.

Ещё один фейспалм (на мой взгляд):

"aaab".match(/a{1,2}/g) // ["aa", "a"]

"aaab".match(/a{1, 2}/g) // null

я тоже думаю что javascript плохой, потому что он за меня не ходит на работу )

Я не говорю, что он плохой (он замечательный!). Просто есть моменты, которые меня удивляют тем, что они не были исправлены ГОДАМИ, и переходили из версии в версию.

Зачем, например, нужен эффект, который я описал в предыдущем посте?

Понять и простить )
А так никто никому ничего не должен, не нравится - делаешь Pull Request )...

Это не эффект, а реакция на синтаксическую ошибку в регулярном выражении

"aaab".match(/a{,2}/g)
"aaab".match(/a{*,;}/g)

Дадут тоже самое.

В javascript вообще нет такого понятия, как индекс массива. Есть свойства объекта. Они задаются строками (ну еще Symbol).

Eсли бы стандартом стал бы vb-script, я бы до сих пор сидел бы в Си и мне начхать было на тот же HTML5 с его WebGL…:-E

Это почему? Нет ассоциативных массивов, это да, но массивы в JS имеют индексы.

Какие индексы?
Массивы - это прежде всего объекты. Ну с некоторыми дополнительными прибамбасами (экзотические объекты). Но объекты.
Индексы - это строки. Все числовые индексы преобразуются в строки и обрабатываются, как обычные свойства объекта.

let a=[1,2,3]

console.log (a[2]); // 3
console.log (a['2']); // 3
console.log (a['02']); // undefined '2' !== '02'

a['1.5'] = 15
console.log (a[1.5]) // 15

a[-1] = -1
console.log (a[-1]) // -1
console.log (a['-1']) // -1

А что в Вашем понимании ассоциативный массив?
Чем обычный объект не ассоциативный массив?
Только, что length нет. Да не особо и нужен.
Весь "ассоциативный массив" обработать можно через for in.

Массивы в JavaScript индексируются с нуля: первый элемент массива имеет индекс, равный 0, а индекс последнего элемента равен значению свойства массива length минус 1.

Это из одного из талмутов, другого суждения я ни где не встречал. А крутить и вертеть словами можно как угодно, о тех же "ассоциативных", сравнивая их с понятиями "свойства".

Это не слова. Это работающие операторы javascript.
let a=[];
a['1.5'] = 15
console.log (a[1.5]); // 15

a[-1] = -1
console.log (a[-1]); // -1
console.log (a['-1']); // -1

Единственная экзотичность объекта Array связана с обработкой свойства length.
В остальном это обычный объект, где даже целочисленные свойства представлены строками.

И к чему это все? Что значит обращение к элементу массива array[3], это по его индексу или есть иной термин, о котором знаете только вы?

Можно мусолить о различиях столько, что на диссертацию хватит, но есть понятие индекс, все остальное это уже словоблудие. Ибо если сравнивать тот же РНР с JS, в первом ассоциативный массив имеет ключи и никто, и ни когда не назовет их свойствами. В отличие от JS в РНР можно всегда получить третий символ строки как string[2] так как во внутреннем представлении в РНР строка это массив, а в JS нет. Но сколь лясы не точи, что в РНР, что в JS, это строковый тип данных. Вот так и с индексами, определят иное понятие этого тогда другое дело.

Вы, наверно, чего то не знаете
console.log('string'[2]); // r

Это взять свойство объекта array с именем '3'

Знаю, но это с ECMAScript 5, а в РНР это было всегда. Поэтому глубоко рассуждать о том, что принято как понятие/термин, какой смысл.

Ну просто это определение языка. Его синтаксис и семантика.

https://www.ecma-international.org/e...9.0/index.html

Определяется понятие объекта. Определяется, что имена свойства объекта - строки. Вводится понятие "целочисленного индекса" причем для обычных объектов тоже. Но говорится, что это все равно строка

6.1.7
Properties are identified using key values. A property key value is either an ECMAScript String value or a Symbol value. All String and Symbol values, including the empty string, are valid as property keys. A property name is a property key that is a String value.

An integer index is a String-valued property key that is a canonical numeric String (see 7.1.16) and whose numeric value is either +0 or a positive integer ≤ 253-1. An array index is an integer index whose numeric value i is in the range +0 ≤ i < 232-1.

А дальше добавляется некоторая "экзотика" для объектов Аrray, Snring, Function...
Но нигде не говорится, что индекс массива, это что то иное, чем свойство объекта, заданного строкой.

Вообще разгвор (мой пост) начался с того, почему не сделать в javascript отрицательные "индексы" у массивов.
Потому, что они уже есть. Но у них другая семантика. А менять семантику того, что уже есть, и быть может, как то кем то используется - низя!

Экзотика, не экзотика, но индекс определен, это ни какое-то эфемерное понятие. )

А если углубляться и для различных языков, то "Чем обычный объект не ассоциативный массив?" в JS, это нечто приближенное, а в РНР именно ассоциативный массив. А если привести его к объекту, то работать с ним как с массивом уже не получится. В js можно и так object.property, и так object[property], а вот в РНР с объектом только так object->property, а так object[property], это фатальная ошибка.

А какое? Чем оно отличается от имени свойства?
Ну в С или каком другом языке это можно понять как номер элемента в последовательности, расположенной в памяти.

А если так
let a = [];
a[0]=0; a[1]=1; a[3]=3;

console.log(a[2]); // undefined ну нет элемента, так чего с него взять.

А если так
Array.prototype['2']=2;
let a = [];
a[0]=0; a[1]=1; a[3]=3;

console.log(a[2]); // 2! Ух ты! Так его же нет!
И получается, что массив ведет себя как голимый объектишко.
И когда нет элемента с индексом, он зачем то лезет в прототип. Прототип то объект - у него нет индексов, а только свойства с именами. А наш массив зачем то вместо индекса лезет за свойством по его имени.
Да просто индексы - это всего лишь имена (строковые) свойств.

Так есть понятие или нету? А то я запутался :D

Если в спецификации говорится об индексах, то понятие определённо есть!

Например, для меня было очевидно, что такие методы должны уметь работать и «вперёд» и «назад». Поэтому когда я узнал про indexOf, то я практически сразу узнал про lastIndexOf, когда задался вопросом, а как то же самое сделать с конца строки. (Тоже самое было с методами списка reduce и reduceRight и пр.)

Совершенно не логично — оно скорей подсказывало бы, что если есть firstIndexOf, то должен быть и secondIndexOf и thirdIndexOf и...

Все объекты (включая и списки — экземпляры класса Array) в JS наследуют от класса Object, а значит они все похожи на экземпляры класса Object. Однако дальнейшее наследование позволяет описать более подробно структуры данных, а это значит, что у списков могут быть описаны индексы. (Согласно спецификации, объекты списка — это такие объекты, которые обеспечивают особую обработку определенному классу имён свойств — включая целочисленные индексы списка, числовое значение i которых находится в диапазоне +0 ≤ i < 2³² − 1. https://tc39.es/ecma262/#sec-array-exotic-objects)

Т. е. вы можете обработать отдельно и собственные свойства списка как объекта и индексы списка.

var xs = [1,2,3];
xs["1.5"] = 15;
xs["-1"] = -1;

console.group("собственные свойства списка как объекта");

for(const [key, value] of Object.entries(xs)) {
	console.log("свойство:", key, "значение:", value);
}

console.groupEnd();

console.group("индексы списка");

for(const [index, element] of xs.entries()) {
	console.log("индекс:", index, "элемент:", element);
}

console.groupEnd();

var a = [];
a[15] = "⛵";
a[4371813261] = "⛴";
alert(a.length); // 16

Ложь! Таких свойств — 4294967296. Свойство length, а также целочисленные индексы от 0 до 4294967294. Т. е. если вы возьмёте 4294967295 или большее целое число, то это число не будет являться индексом списка и не будет влиять на длину списка. См. пример выше.

Это частный случай ассоциативного массива — когда ключами могут являться строки (числа приводятся к их строковому представлению) и символы. (а не любые типы данных)

В РНР — это только частично ассоциативный массив, т. е. его ключи ограничены типом строка, что означает, что он ничем не отличается от экземпляра класса Object в JS. (объект в JS мощней, поскольку ключами могут быть ещё и представители типа Symbol)

Ассоциативный массив — это такой тип данных — коллекция, состоящая из таких пар (ключ, значение) — что всевозможные ключи представлены в ней только один раз.

Смотрим в PHP, разные ключи 5 и "5" не могут быть представлены в так называемом «ассоциативном массиве», а значит — это не настоящий ассоциативный массив.

<?php

$a = [
	5 => "Hi, guys!",
	"5" => "Hi, y’all!"
];

echo json_encode([
	length => count($a),
	keys => array_keys($a),
	elements => array_values($a)
], JSON_PRETTY_PRINT);

Запускаем...
Отличие в том, что в PHP неправильно названа структура типа «коллекция пар (строка, значение)», это явно не ассоциативный массив. Эта структура скорей соответствует тому, что было в ECMAScript 3 и называлось объектом. (но только, опять же, частично!)

Ассоциативный массив реализован, например, в C# — Dictionary, Java — HashMap, JavaScript — Map.

Так если сравнивать, то следует сравнивать подобные вещи! Например массив в C имеет конкретную длину, которая указывается при его инициализации, массив заполняется нулями, а затем вы можете указать конкретные элементы, как вы это делали тут в примере. (в JS это TypedArray)

var a = new Float64Array(4);

console.log(a); // массив заполнен нулями

// изменяем массив
a[0]=0; a[1]=1; a[3]=3;

console.log(a[2]); // 0, а вы ожидали что-то другое?

Экземпляры класса Array не используют никакую отдельную область памяти для хранения (как это делают типизированные массивы, см. пример выше), свойства, представленные целыми числами от 0 до 4294967294 включительно хранятся как и все остальные свойства объекта типа Array — именно как свойства, поэтому если вы напишете Array.prototype[2] = 2 или наоборот что-то не объявите, вы получите точно такой же результат, как если бы работали с экземпляром класса Object.

Однако именно свойства, представленные целыми числами от 0 до 4294967294 означают индексы списка, по которым можно получить соответствующие элементы списка. Все методы списка работают именно с индексами.

Рассмотрим ещё пару примеров с вашим списком...

var xs = [1,2,3];
xs["1.5"] = 15;
xs["-1"] = -1;

// элементы списка можно получить по индексам
alert(JSON.stringify(xs));

var a = new Array(4);

console.log(a); // список ничем не заполнен [empty × 4]

// изменяем список
a[0]=0; a[1]=1; a[3]=3;

console.log(a); // [0, 1, empty, 3]

// только для voraa, если вам нужен массив с предопределёнными
// значениями, то используйте наследование от класса Array
Array.prototype[2] = 2;
Array.prototype[20] = 20;

var a = new Array(4);

console.log(a); // список ничем не заполнен [empty × 4]
/*

Однако на самом деле теперь индексы 2 и 20 есть у всех массивов,
однако инициализируя массив при помощи [] или new Array(4),
свойство length определяется на самом списке (у каждого списка своя длина)

{
	length: 4,
	__proto__: {
		"2": 2,
		"20": 20,
		length: 21,
		constructor: Array,
		// остальные методы и свойства
		__proto__: {
			constructor: Object,
			// остальные методы и свойства объекта
			__proto__: null
		}
	}
}

*/

// изменяем список
a[0]=0; a[1]=1; a[3]=3;

console.log(Array.from(a)); // [0, 1, 2, 3]

// Однако ручная инициализация приводит к тому,
// что видны все элементы
console.log(({ __proto__: Array.prototype }).map(v => v)); // [empty × 2, 2, empty × 17, 20]

// Ещё пример...
var b = { __proto__: Array.prototype };
b.push(22);
console.log(b); // [empty × 21, 22]
console.log(Array.from(b)); // [undefined × 2, 2, undefined × 17, 20, 22]

Списки так работают, поскольку они не используют отдельный объект для своих элементов, что компенсируется тем, что у списков есть множество методов, что позволяет исключить прямое манипулирование индексами.

Такой метод предполагает дополнительные проверки, получение последнего элемента, обёрнутого в контейнер (в данном случае список), позволяет почувствовать всю мощь монад! (Работает уже сегодня)

array.slice(-1).forEach(item => {
	// do something with last item
});

Вытаскивание элемента из контейнера (в данном случае список) предполагает дополнительные проверки!

const item = array.last();

if(item) {
	// do something with last item
});

Malleys,
:thanks:

Стоило открывать дважды Америку, если и ежик знает, что массив не может содержать дубликаты ключей, как и объект дубликаты свойств, ключ/свойство примет последнее значение. А чтобы это увидеть JS совсем и не нужен.

$a = [3=> 1, '3'=> 2];
print_r($a);
print_r((object)$a);

Array
(
    [3] => 2
)
stdClass Object
(
    [3] => 2
)

Вы часто утверждаете, что в PHP есть «ассоциативные массивы», потом про ту же структуру говорите, что это «массив»... Для ассоциативного массива ключи 3 и '3' являются разными и даже с помощью PHP можно увидеть такую разницу... Однако стоит учитывать, что вы ранее писали, что в PHP есть «настоящие ассоциативные массивы», однако ваш последний пример как раз-таки опровергает такое понимание.

В JS как раз таки можно продемонстрировать работу ассоциативного массива...

var a = new Map();
a.set(3, 1);
a.set("3", 2);

console.log(a); // Map(2) {3 => 1, "3" => 2}
console.log(a.size); // 2

Нет такого правила, что ассоциативный массив обязан различать числа от строк с этим числом. Для языков с нестрогой типизацией такое поведение является ожидаемым.

Трескотня пустая.

Массив в PHP - это упорядоченное отображение, которое устанавливает соответствие между значением и ключом. Этот тип оптимизирован в нескольких направлениях, поэтому вы можете использовать его как собственно массив, список (вектор), хэш-таблицу (являющуюся реализацией карты), словарь, коллекцию, стэк, очередь и т.п.

Ключ может быть либо типа integer, либо типа string. Значение может быть любого типа. Дополнительно с ключом будут сделаны следующие преобразования:

◦ Строки, содержащие целое число будут преобразованы к типу integer. Например, ключ со значением "8" будет в действительности сохранен со значением 8. С другой стороны, значение "08" не будет преобразовано, так как оно не является корректным десятичным целым.
◦ Числа с плавающей точкой (тип float) также будут преобразованы к типу integer, т.е. дробная часть будет отброшена. Например, ключ со значением 8.7 будет в действительности сохранен со значением 8.
◦ Тип bool также преобразовываются к типу integer. Например, ключ со значением true будет сохранен со значением 1 и ключ со значением false будет сохранен со значением 0.
◦ Тип null будет преобразован к пустой строке. Например, ключ со значением null будет в действительности сохранен со значением "".
◦ Массивы (тип array) и объекты (тип object) не могут использоваться в качестве ключей. При подобном использовании будет генерироваться предупреждение: Недопустимый тип смещения (Illegal offset type).

Если несколько элементов в объявлении массива используют одинаковый ключ, то только последний будет использоваться, а все другие будут перезаписаны.



Тоже самое будет и в JS, если var o = {1: 1, '1': 2}, то в результате будет одно свойство со значением 2. И речь шла о массивах и объектах. JS, это не нечто исключительное, в других языках тоже всякой хрени полно, сравнивать их, это если делать нехер и времени свободного хоть отбавляй, а если охота, пожалуйста.

Однако в большинстве языков программирования (если говорить об ассоциативных массивах) такое различие делается, т. к. числа и строки — это разные типы.

А вот объект языка программирования (даже если говорить о языках с нестрогой типизацией), который можно рассматривать как коллекцию пар (строка, значение), как раз не делает различия между числом и строками с этим числом — происходит приведение имени свойства/поля/метода к строковому значению.

Совершенно нет! Просто вы путаете динамический объект/объект представляющий класс с ассоциативным массивом.

Ключ типа integer неявно приводится к строке, поскольку вы не можете использовать такой же ключ типа string. То, что вы описали — это объект языка программирования. Учитывая, что можно менять его свойства как угодно — это как dynamic object в C# или Object.create(null) в JS.

И как такое может называться ассоциативным массивом в PHP? Какое тут может быть соответствие одного значения (ключа) к другому значению, когда ключи безвозвратно утрачивают информацию, порождая коллизии?

Вот класс DS\Map в PHP — это действительно работает как ассоциативный массив, имеет методы для работы с ним. (Также Map в JS, Dictionary в C#, HashMap в Java и пр.)

А то, что в PHP возвращает array() — это даже не массив (некоторые там разглядели список, вектор, хэш-таблицу, словарь, коллекцию, стэк, очередь), а просто динамический объект, у которого даже нет своих методов для работы... Этот динамический объект можно расширять какими угодно свойствами, массивом он от этого не станет.

Этот динамический объект некоторым кажется массивом, однако стоит учитывать, что он таким кажется от того, что его передают в различные глобальные функции типа array_*, count и пр. которые имитируют работу этого т. н. «массива»/«ассоциативного массива»/«вектора» и пр.

Конечно — это же динамический объект, как array() в PHP.

Да, действительно есть!

<?php

$a = new DS\Map();
$a -> put(3, 1);
$a -> put('3', 2);

print_r($a);
// Ds\Map Object
// (
//     [0] => Ds\Pair Object
//         (
//             [key] => 3
//             [value] => 1
//         )

//     [1] => Ds\Pair Object
//         (
//             [key] => 3
//             [value] => 2
//         )

// )

print_r($a -> count());
// 2

Это вы наверное пристально вглядываетесь в вывод от print_r — он действительно не различает строки и числа, как в примере выше, но сами объекты правильного типа!

Пурга словесная, ведь изначально речь шла только о массивах и объектах. А ассоицатитвный массив, это ни как не 1 и "1" ключи, это "a", "b", ... ключи. И такой массив, наряду с индексным, имеет тот же набор функций, а в JS "аналог" нет, ибо это объект. А "просто динамический объект, у которого даже нет своих методов для работы...", это воспаленный бред, если только не рассматривать его как и "есть ли определение индекса в js массиве" для словоблудия.

Кроме этого результат работы функций может отличаться от типа ключей массива. Хотя это может и показаться странным, но такое поведение имеет плюсы, например при объединении запросов в БД.

Любишь ты языком чесать, надоел уже.

Что там в большинстве языков - не имеет значения, тем более что запрета на такие различия тоже нет.

Если что-то соответствует определению ассоциативного массива, значит оно им и является. Всё остальное - такая же демагогия, как и про отсутствие понятия индексов в javascript:

laimas, Белый шум, смотрите, я например в С# (Unity3D) могу описать отношения между игроком (класс GameObject) и питомцем (класс GameObject)

var pets = new Dictionary<GameObject, GameObject>();

T. е. в качестве ключей используется экземпляр класса GameObject. И зная игрока, я могу получить его питомца.

Теория теорией, однако на практике это в PHP не работает...

<?php

class GameObject {
	public $name;

	function __construct($name) {
		$this->name = $name;
	}
}

$laimas = new GameObject("laimas");
$cock = new GameObject("петушок — золотой гребешок");

$malleys = new GameObject("Malleys");
$dino = new GameObject("T-rex");

$pets = [
	$laimas => $cock,
	$malleys => $dino
];

print_r($pets);

Это, конечно, печально, но означает ли это что массивы в PHP не соответствуют определению ассоциативных массивов? Разработчики PHP считают, что не означает...

Да, не соответствуют. В РНР — это только частично ассоциативный массив, т. е. его ключи ограничены типом строка, что означает, что он ничем не отличается от экземпляра класса Object в JS.

Зачем вообще в РНР упоминается в связи с [] или array() название ассоциативный массив — неясно, почему нельзя называть вещи своими именами — динамический объект, экспандо (оно ведь и есть объект-распашонка) или расширяемый null. Функции json_encode и json_decode могут показать это!

[] или array() не могут произвести ничего такого, чего нельзя было бы представить при помощи JSON.

Разработчики PHP считают и многие другие нетрадиционные и странные вещи нормальными...

Т. е. для PHP условие — '247' > '0000247' неверно, а равенство '247' == '0000247' верно. Это значит, что PHP... «Разработчики PHP считают, что не означает...»

Учитывая, что в PHP любая переменная может возникнуть в любом месте (с тем самым значением NULL) и даже не произойдёт завершение с ошибкой, означает ли, что PHP... «Разработчики PHP считают, что не означает...» Это норма — говорит PHP, что NULL ведёт себя как −∞.

Много ещё есть вещей типа «Это норма — говорит PHP», однако однажды случилось такое... Я думаю, что в PHP стоило ожидать, что нечто такое произойдёт — T_PAAMAYIM_NEKUDOTAYIM. Если в традиционных языках написали бы в ошибке T_DOUBLE_COLON, то в PHP проявляется неконсистентность даже среди языков, на которых именуются операторы языка. Это означает, что в PHP... Ах, простите, «Разработчики PHP считают, что не означает...» Это норма — говорит PHP.

Просто найдите общее определение ассоциативного массива, которое соответствует вашему пониманию, и на этом закончим.

В тех определениях, которые встречались мне, говорилось либо о ключах-строках, либо о самом понятии ассоциативности:
т.е. если массив заточен не на последовательные числа, а на произвольные значения в ключах (любого типа), то его можно назвать ассоциативным (иными словами, если массив поддерживает только объекты в качестве ключей, то он всё-равно ассоциативный).

http://kvodo.ru/associative-array.html

Белый шум, это всё верно и статья хорошая (с примером на C++ — map <string, string> library;). Но причём тут PHP?

PHP с его объектом совсем не соответствует тому, что там описано...

Берём null ($notDefined не объявлен) и расширяем его...
Этот null ведёт себя как proxy, поэтому «похапешники» вообразили, что это «ассоциативный массив», однако, например, я недавно обнаружил, что он может вести себя и как −∞.

Malleys,Просто найдите общее определение ассоциативного массива, которое соответствует вашему пониманию, и на этом закончим.