ещё комментарии
Ты просто слишком детально начал объяснять ошибку) Во втором случае должно быть не var Text, а String Text, или var Text:String в зависимости от синтаксиса. Само объяснение то правильное)
раскрыть ветку (1)
Объяснение автора ветки неправильное и я объяснил почему в своём комментарии, читай его #comment_96616785 автор путает всё что только можно перепутать.
ещё комментарии
Представь у тебя есть коробка. После того, как ты налил в эту коробку воду, она уже не сможет содержать ничего кроме воды, и ты сможешь выливать ее, заливать снова, но положить плюшевого мишку, кота или комиксы не сможешь - они испортятся.
Это строгая типизация.
Так где бы ты ни был в комнате, ты не будешь боятся класть туда вещи, и даже не глядя на содержимое коробки будешь знать, что было и есть внутри, так как мама скажет тебе, ПРИДУРОК ЭТО КОРОБКА ДЛЯ ВОДЫ, вытащил на хуй, а то пизды получишь. Что позволяет не думать о том, что это блядь за коробка, за тебя это помнит мама.
К тому же ты сможешь легко понять, что это коробка с водой, по подтекам например, или эта с органами, из за крови, и тебе будет поебать, что там внутри, ты будешь держаться от них подальше со своими комиксами и котом.
А в динамической типизации ты живешь один. А все коробки с квантовой неопределенностью. И ты разъебай не помнишь, коробка из под пиццы это или шампуня. Никто за тебя не скажет, что ты делаешь что то не так, и Васек, твой брат дебил, не налил туда уже воды.
И ты такой оп, кот в коробке, но хуй знает сдох он там или нет, пока не откроешь коробку не поймешь. Потому что это динамическая типизация - безотказная коробка и отсутствие проверки мамой позволяет портить данные и вещи.
Но иногда динамические типы полезны. Тот же С# имеет в себе динамический тип, позволяет преобразовать данные из стринги и бит массива и все такое.
Причина этого проста, иногда даже твоя мама не знает, что внутри коробки. И тогда лучше пометить ее знаком какая то дичь и боятся.
Объяснил?
Это строгая типизация.
Так где бы ты ни был в комнате, ты не будешь боятся класть туда вещи, и даже не глядя на содержимое коробки будешь знать, что было и есть внутри, так как мама скажет тебе, ПРИДУРОК ЭТО КОРОБКА ДЛЯ ВОДЫ, вытащил на хуй, а то пизды получишь. Что позволяет не думать о том, что это блядь за коробка, за тебя это помнит мама.
К тому же ты сможешь легко понять, что это коробка с водой, по подтекам например, или эта с органами, из за крови, и тебе будет поебать, что там внутри, ты будешь держаться от них подальше со своими комиксами и котом.
А в динамической типизации ты живешь один. А все коробки с квантовой неопределенностью. И ты разъебай не помнишь, коробка из под пиццы это или шампуня. Никто за тебя не скажет, что ты делаешь что то не так, и Васек, твой брат дебил, не налил туда уже воды.
И ты такой оп, кот в коробке, но хуй знает сдох он там или нет, пока не откроешь коробку не поймешь. Потому что это динамическая типизация - безотказная коробка и отсутствие проверки мамой позволяет портить данные и вещи.
Но иногда динамические типы полезны. Тот же С# имеет в себе динамический тип, позволяет преобразовать данные из стринги и бит массива и все такое.
Причина этого проста, иногда даже твоя мама не знает, что внутри коробки. И тогда лучше пометить ее знаком какая то дичь и боятся.
Объяснил?
раскрыть ветку (3)
> После того, как ты налил в эту коробку воду, она уже не сможет содержать ничего кроме воды
> Это строгая типизация.
Нет, это называется статическая типизация. Строгая типизация означает, что нельзя сложить коробку с водой с коробкой с другим содержимым.
раскрыть ветку (2)
Строгая типизация - это когда ты говоришь, что переменная типа "строка". И все, там лежит строка. И никогда там не будет лежать что-то другое. Ты можешь туда засунуть только другую строку.
Динамическая - это года ты что хочешь, то и кладешь. Сейчас строку, а тремя строками ниже - число. Или массив. Или кошку.
Чем лучше динамическая - удобнее программисту. Меньше писать, не надо думать, какой тут должен быть тип.
Чем лучше статическая - если ты хочешь сделать что-то недопустимое, например умножить кошку на восемь или узнать ее длину, тебя об этом никто не предупредит. Все будет компилироваться и упадет только после запуска.
раскрыть ветку (3)
раскрыть ветку (1)
Формально, описание из первого абзаца подходит и для строгой.
Впрочем, я действительно перепутал.
ну хз
я как прогер на си иногда сталкиваюсь со всякими php и jsscript и вот когда надо гонять из статически типизированого в динамический в принципе проблем нет. а вот вернуть что то такое что я потом смогу принять на стороне со статической типизаций тут мама не горюй.
> Знаешь, после его объяснения я хоть что-то да понял
И зря. Потому что там написана дичь и ересь, которая не имеет к типизации никакого отношения. Приведенный им отрезок кода корректен и в C#, и в JS, в которых противоположны каждый из акспектов типизации - строгость, динамичность, явность.
Смотри, статическая типизация
int i = 0; //тип переменной i - целое число
i = 3.13 //ошибка 3.13 - число с плавающей точкой,а i принимает только целые
Динамическая
i = 0
i = "Это строка"
Строгая
i = "Это строка"
i = i+1//ошибка, строку нельзя сложить с числом
Слабая
var i = "Это строка"
i = i + 1//Верно, 1 будет преобразовано в '1' и результат "Это строка1"
Уже тысячу раз ответили, что он не прав, но почему бы и мне не попрактиковаться в красноречии?
Динамическая типизация: у нас есть бутылка. Мы можем налить в неё воду или метанол. Как только налили — у нас появляется либо бутылка с водой, либо бутылка с метанолом.
Статическая типизация(противоположность динамической): мы заранее берем отдельную бутылку под воду — в ней может быть только вода. А в заранее подготовленной бутылке с метанолом ничего кроме метанола не окажется.
Слабая типизация — мы можем смешать метанол с водой, или, перепутав бутылку, и вовсе выпить чистый метанол. Почему мы умерли? Никто не знает, программа делала всё правильно — ошибку придется искать очень внимательно, выясняя, когда мы перепутали содержимое(или бутылку).
Сильная(строгая) типизация — мы не можем выпить метанол, ибо такое поведение для него намеренно не создано. Смешать с водой его тоже будет затруднительно, разве что воссоздавать с нуля на молекулярном уровне новую жидкость, где будет требуемое соотношение воды и метанола.
Именно в этом смысл поста — динамическая типизация не может быть хуже или лучше строгой, ибо это два несвязанных понятия, не являющиеся ни синонимами, ни антонимами. Попытка выявить лучше среди них, это попытка узнать, что же лучше, синий цвет, или теплая вода.
Динамическая типизация: у нас есть бутылка. Мы можем налить в неё воду или метанол. Как только налили — у нас появляется либо бутылка с водой, либо бутылка с метанолом.
Статическая типизация(противоположность динамической): мы заранее берем отдельную бутылку под воду — в ней может быть только вода. А в заранее подготовленной бутылке с метанолом ничего кроме метанола не окажется.
Слабая типизация — мы можем смешать метанол с водой, или, перепутав бутылку, и вовсе выпить чистый метанол. Почему мы умерли? Никто не знает, программа делала всё правильно — ошибку придется искать очень внимательно, выясняя, когда мы перепутали содержимое(или бутылку).
Сильная(строгая) типизация — мы не можем выпить метанол, ибо такое поведение для него намеренно не создано. Смешать с водой его тоже будет затруднительно, разве что воссоздавать с нуля на молекулярном уровне новую жидкость, где будет требуемое соотношение воды и метанола.
Именно в этом смысл поста — динамическая типизация не может быть хуже или лучше строгой, ибо это два несвязанных понятия, не являющиеся ни синонимами, ни антонимами. Попытка выявить лучше среди них, это попытка узнать, что же лучше, синий цвет, или теплая вода.
Чел, не подумай, что я не рад снова тебя видеть или что хочу выгнать тебя, но.. у тебя что, совсем что ли больше нет дел, кроме как сидеть на пикабу?
раскрыть ветку (8)
Весь этот месяц я делал практику по 8 часов 6 дней в неделю (про нее, кстати, на этой неделе пост будет, я наделал фоточек) в больнице, еще где-то по 2 раза в неделю я делал практику в другой больнице из-за курса по выбору, плюс я еще готовлюсь потихоньку к экзамену по анатомии 9 октября, плюс раз в неделю где-то встречался с друзьями на выходных. На пикабу сижу реально меньше обычного.
И стало мне интересно - а насколько упало количество комментариев, которые я пишу в день? Я ожидал, что вместо 63 в день у меня будет где-то 40, а то и 30 в день, ведь я сижу тут мало. Посчитал и оказалось, что я пишу... 58 комментариев в день.
Иными словами: мне для того, чтоб писать много комментариев, не надо целый день сидеть на пикабу. Просто то время, пока меня нет, никто не замечает. А когда я-таки добираюсь до компа, то меня резко становится много. И на это резкомногостановление мне много времени не надо.
P.S. хотя сегодня я был в позднюю смену (это значит, что успел поднасрать в комментах с утра) и смена халявной была, меня не дергали практически, я поэтому учился и зависал на пикабу.
раскрыть ветку (5)
Ой, да чо ты мажешься, нет у тебя личной жизни, нет учебы, нет практики, ты сидишь ВЕЧНО на пикабу и печатаешь....печатаешь, строчишь и строчишь комменты.
И как тебя тянет так много писать, я иногда даже открою окно, чтоб напечатать, а потом подумаю, а нахуя? Нахуй кому то упало мое мнение, а мне что-то доказывать и закрою )
раскрыть ветку (3)
"я иногда даже открою окно, чтоб напечатать, а потом подумаю, а нахуя? Нахуй кому то упало мое мнение, а мне что-то доказывать и закрою ) "(с)
Этот коммент однако набросал
Этот коммент однако набросал
раскрыть ветку (1)
Меня всегда от таких комментариев на поржать тянет :D.
Когда есть смысл спорить и что-то доказывать, то я могу это развлечения ради сделать, тут же бог с тобой, верь во что хочешь, мне настроение поднял и хорошо)
Поделись машиной времени =_= Откуда у тебя на это всё( + Пикабу + что-то ещё) есть время?
Ну... мне, пожалуй, не дотянуть но Л4евера, но я тоже достаточно много времени тут провожу и комментариев оставляю (за сегодня 36).
Есть же время, проведенное в дороге(учитывая, что я учусь на другой стороне Москвы-это дохрена времени), скучные пары, валяния в кровати перед сном...
Есть же время, проведенное в дороге(учитывая, что я учусь на другой стороне Москвы-это дохрена времени), скучные пары, валяния в кровати перед сном...
раскрыть ветку (1)
как я понял...
Java - строгая типизация данных.
Пример:
String pizdec = "polniy pizdec";
тут переменная pizdec тип данных String, то есть текст, присваевается значение "polniy pizdec". Строгая типизация типа данных.
PHP - не строгая типизация данных(полный...)
Пример:
$pizdec = "polniy pizdec";
$pizdec - переменная которой присваивается значение "polniy pizdec" и php знает что это String, то есть текст.
Ну и следовательно появляются нюансы... Я правильно понял?
раскрыть ветку (17)
Вот так, на примере:
c#, строгая типизация (тот же Java, только черный, толстый, упругий и в другой руке)
string pizdec = "polniy pizdec"; //мы сказали, что это текст. он навсегда останется текстом и ты не сможешь сделать с ним ничего "не текстового", вроде умножения или степени (если сам не запрограммируешь его реакцию на такие манипуляции).
pizdec = 2*4; //ошибка компилятора, ты даже не соберешь программу, потому что у тебя попытка присвоить текстовой переменной числовое значение
javascript, чад кутежа
var pizdec = "polniy pizdec" //переменная "pizdec" со значением "polniy pizdec"
pizdec = 2*4; //теперь там 8
pizdec = 5 + "вингорад" //угадайте что? "5виноград"
pizdec = pizdec / 5 //и даже сейчас нет ошибки, значение - NaN (Not a number, не число, технически, тоже число, наравне с Infinite - бесконечностью, все математические манипуляции с ним будут валидны, просто он так и будет оставаться "не числом")
pizdec = function() { console.log("kill me") } // грубо говоря, там где у нас было число, теперь функция - набор действий. Мы только что превратили номер пять в прыгать. Теперь, если написать pizdec(), то он выведет в консоли "kill me".
pizdec = ["polniy pizdec",2*4,function() { console.log("kill me") }] // теперь это массив значений, в первом - "polniy pizdec", во втором - 8, а в третьем - функция из предыдущего пункта. pizdec[2]() все еще просит его убить.
раскрыть ветку (11)
раскрыть ветку (4)
раскрыть ветку (3)
раскрыть ветку (2)
раскрыть ветку (1)
унарный оператор - преобразовал '2' к 2, поменял знак получилось -2, + преобразовал -2 к строке '-2' и сложил со строкой '5'
Начнем с того, что в C# ужа давненько появилась условная типизация.
var pizdecpizdeckiy = 123;
var prostopizdec = "ну это уже ни в какие ворооота!";
Но это только синтаксический сахар. Язык по-прежнему считается статически типизированным, но вот объявлять конкретный тип переменной уже не нужно - только тип данных.
раскрыть ветку (4)
раскрыть ветку (3)
раскрыть ветку (2)
раскрыть ветку (1)
Вон оно чё... Нет, я с шарпом не настолько плотно сидел. Да и теперь, почитав, не считаю это хорошей идеей, в статически типизированный язык добавлять динамически типизированный тип... На крайний случай можно уж и с дженериками что-то придумать, абстракцию применить.
Ну с тем, что java сильная (сильная, не строгая, нет строгой типизации), а php слабая, ты угадал, но не причину. К примеру с\с++ считают слабо типизированным. Но этим никто не пользуется. Да и строгого определения в отличии от статической\динамической типизации нет. Критерии премерно такие: в сильно типизированных нет неявных преобразований типов, и данные, которые изначально были одном тиром нельзя вести как данные другого типа. Вот в java все преобразования довольно явные, вот в с++ можно любой любые данные вести себя как данные определённого типа, если этот им имеет такую-же длину (reinterpret_cast). Им, вроде, никто и не пользуется, но он, вроде и есть). А вот неявными преобразованиями типов ещё как пользуются.
Вот в php твоя строка запросто и без дополнительных манипуляций может вести себя как множество, если ты её впихнёшь не туда (или у тебя хитроумный план (читай быдлокод (хотя не пишу на php, может там так заведено)))
Вот в php твоя строка запросто и без дополнительных манипуляций может вести себя как множество, если ты её впихнёшь не туда (или у тебя хитроумный план (читай быдлокод (хотя не пишу на php, может там так заведено)))
раскрыть ветку (4)
Конечно заведено. Вообще создаётся впечатление что он просто создан для того чтобы создавать один массив который включает в себя ВСЁ. Чего далеко за примерами ходить, достаточно на битрикс посмотреть. Да фиг с ним с битриксом. Одна переменная $GLOBALS чего стоит.
Жабка перестаёт быть статически типизированной, как только студент узнает о рефлексии!
А в дельфе вообще строка и является идеальным массивом байт, особенно при чтении сокетов.
раскрыть ветку (1)
Опять-же, всё в сравнении. В с++ есть тоже динамическая загрузка классов. И подсунуть туда можно что угодно. Но большая часть кода имеет статическую типизацию
Тут надо наверное уточнить, что сама конструкция var Text = "тупо текст" уже сама по себе пример динамической типизации. При статической тип переменной указывается рядом с переменной во время её первого объявления, например var string Text = "тупо текст"
раскрыть ветку (14)
тогда c++ - язык с динамической типизацией, т.к. есть auto:
auto it = myList.begin();
или еще "хуже":
for (auto& item : myList)
{
...
}
не путайте запись и смысл
раскрыть ветку (5)
auto выводит тип, ориентируясь на операции с членами этого типа и делает это на этапе компиляции, а не динамически — на стадии работы программы.
Динамическая типизация, это когда ты заранее не можешь сказать, какой переменная станет во время работы. Когда узнаешь её тип, тогда и будут ясно, как и какими методами работать с переменной. И при этом типизация может быть как сильной, так и слабой.
раскрыть ветку (2)
раскрыть ветку (1)
Я заметил это только после отправки двух сообщений. Вот так вот — открыть сообщение не из ленты, а из похожих)
раскрыть ветку (1)
значит я уже сломал пальцы всем своим родственникам до 5го колена :)
на каждый чих typedef не напишешь
на каждый чих typedef не напишешь
Не обязательно. В фортране можно не указывать тип переменной вообще, но там статическая типизация. Вы говорите о явном и неявном указании типов(explicit and implicit typing)
В шарпе var Text = "тупо текст" работает. Более того auto Text = "тупо текст"; в с++ работать будет. Нет, здесь не разница в том, указал ли ты тип сам, или компилятор, а в том, что что при статической типизации тип определяется в момент объявления (и не меняется), а при динамической в момент определения (в момент присваивания) (и может меняться в процессе работы).
А потом либа от майков добавляет новых 10 типов текста и интов, которые используются только в ней, а другая либа еще 20 видов и ты думаешь как из одного ебнутого инта перевести во второй ебнутый инт, чтобы использовать в третьем ебнутом инте, потому что надо работать с тремя либами сразу )
раскрыть ветку (5)
Ну, в общем случае, он правильно преобразует тип. Так же как и int-long-char между собой все-таки сочетаются.
Конечно есть нюансы
Конечно есть нюансы
ещё комментарии
Тот момент, когда вы сказали хуйню, не понимая виды типизаций и все перепутав, но у вас 389 плюсов.
А у комментов, которые правильно объясняют - нет.
Люди путают строгую - слабую типизацию и динамическую - статическую. И еще называют себя программистами. Куда катится мир. Это как путать теплое с мягким в прямом смысле.
раскрыть ветку (1)
Вы путаете строгую и статическую типизацию. Оба приведенных примера - одно и тоже, по сути. При динамической типизации, тип переменной выводиться во время определения!,а при статической во время объявления. То есть корректный пример в данном случае String s = "hello"; так тип может быть проверен на этапе компиляции. Так же существует понятие сильной(строгой) типизации - когда компилятор не может делать преобразований типов, например, из целого в вещественное (но тут можно и поспорить). В хаскеле строгая типизация, а в с++ слабая статическая.
раскрыть ветку (2)
Вообще неправильное объяснение. Динамическая типизация, это когда ты можешь создать экземпляр объекта и прямо в рантайме накидать в него методов и свойств, в итоге ты в рантайме никогда не знаешь, с чем работаешь. С одной стороны это гибко и легко, подходит для маленьких проектов и скриптов, для веб-фронтенда, с другой - приводит к бардаку и код по мере разрастания разваливается, кроме того, его сложнее анализировать. Пример - JavaScript, где объект - это тупо словарь, с которым можешь делать всё, что хочешь.
Статическая типизация - это когда метаданные класса (набор методов и полей/свойств) заранее определены и все проверки проходят на стадии компиляции, соответственно в рантайме ты всегда можешь рассчитывать на то, что у экземпляра данного класса есть нужные тебе элементы. Это делает код более надёжным, стабильным и понятным (что выгодно в сложных и больших проектах), но свою очередь лишает некоторой гибкости. Пример - C#.
Тут есть нюансы. Например, в C++ можно написать так: auto a = 0; и это всё равно будет статическая типизация, хотя мы нигде не указали явно, что это int.
Динамическая типизация - это когда переменная может менять свой тип по ходу работы программы, в момент присваивания значения, а не тогда, когда мы её объявили.
раскрыть ветку (15)
Это называется вывод типов. Компилятор на основе твоего кода может вывести тип автоматически. В auto в C+ это довольно примитивный способ вывода типов.
Более продвинутый вывод типов есть в языках с системой типов Хиндли-Милнера (Haskell, F#).
Что-то типа того:
let add x y = x + y // Не указываем типы
add 1 2 // Т.к. 1 и 2 - int, то из данного выражения, в функции add аргументы x и y будут выведены как int
add 3 4
add 1.1 2 // Ошибка компиляции, т.к. выше в add уже вывелся тип int, а здесь 1.1 - float
И таких фишечек в данной системе типов много.
раскрыть ветку (2)
т.к. выше в add уже вывелся тип int
Тут параметрический полиморфизм, так что последний вызов выведется как Fractional -> Fractional -> Fractional и никакой ошибки не будет. https://ideone.com/axbv4A
раскрыть ветку (1)
Мой пример справедлив для F#, там нет типа Fractional, поэтому такой код не прокатит, но можно сделать так:
let inline add x y = x + y
add 1 0
add 1.0 2.0
раскрыть ветку (11)
А нет её, можно создать указатель void *, например, который сможет указывать на любой тип, но это не будет динамической типизацией, так как тип указателя какой был, такой и есть.
раскрыть ветку (8)
Пока пил кофе, камрад выше отлично ответил. Респектую!
P.S. Добавлю только, что типизация может быть либо статическая, либо динамическая (про псевдо-тип dynamic в C#, поручики, молчать!)
раскрыть ветку (3)
хех, не только, вариантов гораздо больше - курим Бенджамина Пирса "Типы в языках программирования"
раскрыть ветку (2)
Не гораздо. Ещё "слабая-сильная" и "явная-неявная". Плюс "явная/неявная по выбору". Только вот не для этого ресурса такие замечания.
А либо/либо в том смысле, что не может быть одновременно и той и другой
раскрыть ветку (1)
ок, но вариантов всё-таки больше - с сопоставлением "по имени/по структуре", "простые/зависимые" и т.д. вплоть до полностью открытой системы как в Qi
раскрыть ветку (3)
Подозреваю, что на шаблонах можно что угодно написать, покопай в сторону Boost, великолепный пример того, как можно использовать язык извращённым способом. Хотя конечно это будут библиотеки на метауровне (в них можно будет любые проверки реализовать), а не сам базовый язык. Считать ли всё это Си++ х.з.
раскрыть ветку (2)
Если исключить каст *void (это единственный способ динамической типизации), то даже Boost не спасёт. Можно использовать union или Boost.Variant, но это не динамическая типизация, а тип-сумма, т. е. множество хранимых типов ограничено.
Можно использовать элементы динамической типизации. Оператором dynamic_cast. Обычно это происходит примерно так: есть несколько наследников, от базового класс. В базовом классе хранится тип наследника. При получении базового класса, считываем тип и используя dynamic_cast кастуем к нужному типу. Так как наследник в памяти хранится всегда строго после базового класса, проблем с этим не возникает. Даже адрес переменной не меняется.
язык программирования сам определяет
язык программирования берет на себя задачу
язык программирования только после этого сообщит
Среда исполнения же. И да, объяснение неправильное.
раскрыть ветку (2)
я бы сказал "платформа" или "реализация" (очень общее и размытое понятие), т.к. это может быть как задача компилятора (C++, С# , Java), так и интерпретатора (Python, PHP, Ruby).
(зануда-мод off)
И да, его объяснение неправильное.
раскрыть ветку (1)
раскрыть ветку (7)
раскрыть ветку (5)
Замечательный язык, хочу сказать!
Из всех ошибок на этапе запуска кода он тебе сообщит только о синтаксических ошибках.
Да и вообще о том, что у тебя в коде что-то не так сделано можно будет догадаться только по тому, что у тебя получится в результате выполнения кода. И время отладки в случае твоей криворукости вырастает просто в охуительнейшие часы и даже дни.
Чукча не писатель, поэтому внезапный вывод на правах имхо: TDD - годная штука для разработки на js.
Из всех ошибок на этапе запуска кода он тебе сообщит только о синтаксических ошибках.
Да и вообще о том, что у тебя в коде что-то не так сделано можно будет догадаться только по тому, что у тебя получится в результате выполнения кода. И время отладки в случае твоей криворукости вырастает просто в охуительнейшие часы и даже дни.
Чукча не писатель, поэтому внезапный вывод на правах имхо: TDD - годная штука для разработки на js.
раскрыть ветку (4)
Вы знаете, я, спустя некоторое время, отказался от TDD. Я взял за себя правило написания функции assert как глобальной (можно заменить console.error, но она у меня это и делает) и правило "никогда не верить входящим данным в методе" вкупе "функция должна делать как минимум два assert'a" и "быть максимально атомарной" - это правила разработки NASA, если что. TDD уже давно не использую, но в случае падения на dev - я всегда вижу ошибку и знаю где искать (это когда данные ну совсем нереальные - в большинстве от server-side). На прод уже проверенный код попадает и assert делает что-то другое (в одном проекте он отправлял мне полный лог ошибок в спец хранилище и перезагружал код).
При этом код полностью покрывается тестами, если требуется, просто нужно создать условия dev и запустить условия выполнения - тогда можно увидеть assert
Есть хорошая "припарка мертвому" -- трансляция Kotlin в js. Не скажу, что многим лучше, но хотя бы явная статическая типизация есть. Вообще, у котлина есть свои плюшки, но тут не подскажу. Я только пробовал простейшее расширение для хрома написать в качестве опытов над психикой человека
раскрыть ветку (2)
Во-первых никто не отменят TypeScript, во-вторых никтогда не видил проблем с динамической типизацией. Не так сложно всегда приводить тип там, где это может иметь значение.
раскрыть ветку (1)
Это "не так сложно" на практике ухудшает понимание кода в разы. Была циферка, стала буковкой, а потом вообще в беляш превратилась. Чужой код читать становится невозможно
В пхп как раз с этим нормально все. Строки клеятся точкой, а не плюсом, и ничего поломаться не может. (1 . 2 = '12') А числа всегда предварительно приводим к нужному типу (int) '1' + (int) 2 = 3.
Ни разу за всю практику у меня не было каких-то багов из-за типов.
Насчет "что ты еблан хочешь" - ай не всегда. Можно радостно получить NaN и протащить через весь цикл вычислений.
Насчет " ААА бля! вот я лапух, уже 100500 функций написал и теперь всё к ебеням переписывать неделю надо! сука! сука!" - название переменной должно отражать то, что в ней находится. Чтобы допустить этот косяк нужно лопухнуться с именем и с объявлением переменной.
Не согласен. Типизация бывает динамическая и статическая, а так-же строгая и нестрогая и оба эти варианта ортогональны, т.е. только по этим двум критериям может быть 4 варианта типизации. Ну а вообще - Бенджамин Пирс "Типы в языках программирования". Но тому клоуну я бы тоже навалял, т.к. "duck typing" зло!
Чет про все к "ебеням переписывать" не понял. А че, нельзя сделать
parseInt(Text); // Имя переменной с большой буквы??
? Ну и посыпать обработкой ошибок.
На самом деле в динамической типизации другая проблема - всегда надо проверять ручками, что у тебя там в переменной лежит. Например переменная var x = "123"; - очевидно же что строка, но так же очевидно, что 123 - это число. Значит можно с ним работать, как с числом. Но если там например "123 " (пробел в конце) - получится кака, хотя очевидно же, что там число 123, но пробел все ломает.
Вот примеры. Можно нажать на F12 и во вкладке console и попробовать самому.
"123" * 3 // = 246, JS понял, что в строке число
"123 " * 3 // = NaN - Not a Number, JS не понял, как умножить строку на число
parseInt("123 ") // = число 123 - parseInt знает, как надо вычленять число даже из такой строки
parseInt("123 321") // = число 123 - ??? parseInt ищет число в строке до первого нечислового символа, все остальное обрезает и остаток конвертирует в число.
В первой части коммента описана неявная, то есть автоматическая типизация. К динамичности - то есть к возможности изменения типа (а не момента вывода ошибок: на этапе компиляции или во время работы программы) это отношения не имеет.
> к примеру var Text = "тупо текст"; язык программирования сам определяет что между двойных кавычек находится текст - это динамическая типизация
Каждый первый язык программирования знает, что между кавычек текст, потому что это строковый литерал. Но я понял, что вы имели в виду.
Тем не менее, из строки кода выше о типизации языка нельзя сказать ничего, кроме того что в нем поддерживается автоматическое выведение типов. Например, эта строка - корректный код C#, в котором сильная (строгая), статическая, явная, номинативная типизация. Она же корректна и в JS, где слабая (нестрогая), динамическая, неявная типизация.
Извини за занудство, но
Статическая vs динамическая типизация
Строгая vs нестрогая типизация.
Фуф, отпустило
Статическая vs динамическая типизация
Строгая vs нестрогая типизация.
Фуф, отпустило
Уважаемый, вы, как я посмотрю, шарите в языках. Хотелось бы спросить: какой язык лучше учить на досуге? Какой наиболее востребованный ныне?
Извините за тупой вопрос, только начинаю идти по пути изучения программирования.
А вот если я в джаве напишу
double x = 2
то при арифметических операциях с этой переменной, результат будет цельночислительный int
а если напишу
double x = 2.0 то всё норм
Не могу вопрос сформулировать, но думаю вы поняли о чём я. спасибо.
раскрыть ветку (1)
В первом случае ты объявил переменную типа double, затем присвоил ей int константу "2". Во втором случае присвоил ей double константу "2.0". Можно double x = 2f писать. Тогда присвоишь тип float (давно не прогил на джаве, может путаю синтаксис но смысл такой)
Ну нихера не понял, давай лучше я расскажу
Допустим создал ты переменную cost = 0, и считываешь в неё данные из списка покупок:
cost += item[i]
И в конце оказывается что стоимость не 16,5, а "3,58,24,8"
То есть переменная была числом, а стала строкой
А в статической типизации переменная как была числом, так и осталось. А на строчку
cost += item[i]
компилятор бы ругался, и просил бы привести item[i] к числовому виду
То, что язык программирования тебя послал, когда ты строку на 2 умножал - это ещё не так обидно. Обидно, когда он тихо увеличил строку в 2 раза и никому ничего не сказал (python) А ты потом сиди и майся где ошибка
я это использую лишь с запросами линк(ну для этого мне кажется в шарпе они и созданы), в оыбчных ифах где в падлу писать int и var хотя ваще не знаю что там легче 3 буквы ебаные, я что дебил? И когда не знаю что я хочу сделать и что должно быть на выходе, а поставим вар, чо получим - то получим
меньше времени на подобный мусор тратишь
Интересно, много времени требуется, чтобы написать String? Зато потом куча времени экономится на поиске ошибок времени выполнения.
зато с динамической типизацией можно num = "10" просто текст, num = num + 0 опа, уже чирик. и наоборот, был чирик num = 10, а тут num = num + "" стал просто текст (lua). но если где-то накосячишь с такой магией то можно долго баг искать.
раскрыть ветку (8)
Но если ты думал, что "2" это число 2 и ты хотел получить умножением 4, то получишь ты нифига не 4, а, вероятно, "22" если я понял как в руби строки умножаются.
раскрыть ветку (2)
мало того, можно в процессе перевести строку с числом в число, сделать над ним операции и перевести опять в строку. ("125".to_i*2).to_s я не знаю как я жил без такого, удобно ведь)
раскрыть ветку (1)
Думаю во всех языках есть преобразования типов, просто реализовано по разному.
А если сильно увлекаться с подобными записями код становится не читаемым.
раскрыть ветку (16)
раскрыть ветку (2)
Это не так уж и редко встречается. В особо запущенных случаях автор после того, как кто-то объяснил шутку, начинает писать свое "видение" шутки и обсирать тех, кто убеждает его в другом.
А, и вот ТС пишет, что ничего не понял, но запостил #comment_96614618
раскрыть ветку (1)
я попробую объяснить, представь что у тебя задача - пропустить детей в школу. ты стоишь у дверей в школу и пропускаешь их. в итоге у тебя вместе с детьми могут зайти парочку бомжей, 8 собак и один педофил. это потому, что тебе четко не задали параметры тех, кто должен пройти, а кто не должен. (ну и потому что ты слепой, а кто тебя назначил на эту работу - долбаёб). это динамическая типизация - впускаю всех в школу, а учитель там уже разберется в классе кто по его мнению ребенок, кто не ребенок, а кто любит детей по настоящему.
статическая типизация - ты стоишь у дверей в школе и у тебя есть четкая инструкция, как определить кого пускать. ребенок это маленький человек, который не старше 18 лет, он ходит на 2х ногах, у него портфель, он живой. мимо тебя проходит толпа и ты каждого ощупываешь - так! есть 4 конечности и он ходит на двух из них, явно ребенок! рост - метр с кепкой, рюкзак за плечами - явно ребенок! проходи... следующий - 4 конечности, стоит на двух, маленький рост, рюкзак за пречами и... и... усы? ёбанный в рот! это же карлик-педофил, которого разыскивают уже пол года! ПОЛИЦИЯ! ПОЛИЦИЯ!
очень коряво, примитивно и, возможно, не правильно =) но как то так
раскрыть ветку (4)
Статическая типизация (C):
int a = 1; //a - число
a = "abc"; //не работает
Динамическая типизация (Python):
a = 1 #a - число
a = "abc" #теперь a строка
Динамика - присваиваем переменной А значение "ахтыжничонепонятна" и ей автоматически задается тип данных Стринг(т.е. строковый). Затем этой же переменной А присваиваем значение "12" и ей уже задается числовой тип данных.
Строгач - прогер сначала задает переменной А числовой тип данных во время объявления переменной в программе, а потом присваивает ей значение "12". Соответственно, если он попытается присвоить переменной А значение "ахтыжничонепонятна", то компилятор выдаст ошибку, так как это не число.
Вообще, если ты хороший программист, то Статика это для тебя, это суровый и защищеный, скажем так, метод. А динамика для нубов, пишущих на питонах и пхп(не обижайтесь пхпшники и питонщики, я шучу на самом деле).
раскрыть ветку (5)
Херня написана...
Динамика - тип переменной определяется во время выполнения кода. Статика - Тип переменной определяется в момент компиляции.
Строгая типизация - не позволяет смешивать типы при операциях. Не строгая типизация - позволяет смешивать типы при операциях.
Шутка как раз таки в том, что было сравнено два разных свойства.
раскрыть ветку (4)
раскрыть ветку (3)
Не надо путать неявную типизацию и динамическую. Слово "автоматически" в первом предложении коммента - лишнее. Неважно, автоматически - то есть неявно, или вручную - то есть явно, задаётся тип.
раскрыть ветку (2)
ещё комментарии
Извините, что пишу под топовым.
Объясню на примере С#.
Динамическая типизация:
var stroka = "HelloWorld";
Статическая типизация:
string stroka = "HelloWorld";
В первом случае если бы мы вместо хелоу написали 0.2f(без кавычек), то переменная stroka была бы float а не string.
Во втором такого быть не может, ибо мы сразу указываем тип переменной. А var это типа мы еще не определились.
Объясню на примере С#.
Динамическая типизация:
var stroka = "HelloWorld";
Статическая типизация:
string stroka = "HelloWorld";
В первом случае если бы мы вместо хелоу написали 0.2f(без кавычек), то переменная stroka была бы float а не string.
Во втором такого быть не может, ибо мы сразу указываем тип переменной. А var это типа мы еще не определились.
раскрыть ветку (4)
var stroka = "HelloWorld";
это автоматический вывод типов, типизация всё равно остаётся статической, т.к. тип переменной определяется в момент компиляции и больше не меняется
динамическая типизация - это когда тип переменной определяется при присвоении ей значения.
например, в php:
$a = 1;
$a = "asdf";
всё валидно, всё работает, тип переменной определяется в рантайме (ну а то что в $a то строка, то число - сам себе злостный буратино)
Нет, у шарпа статическая явная типизация. Также есть поддержка неявного указания типа(var, что ты и описал) и динамической типизации через псевдо-тип dynamic.
В C# нет динамической типизаци.
Вот это динамическая
$temp=2;
$temp="huy";
А в C# есть выведение типов и поэтому stroka как была типа стринг так и будет
Вот это динамическая
$temp=2;
$temp="huy";
А в C# есть выведение типов и поэтому stroka как была типа стринг так и будет
раскрыть ветку (1)
Не совсем так. В C# есть тип dynamic
dynamic t ="123";
t = 500;
Action<string> a = (str) => { Console.WriteLine(str); };
t = a;
t("dynamic");
dynamic t ="123";
t = 500;
Action<string> a = (str) => { Console.WriteLine(str); };
t = a;
t("dynamic");
ещё комментарии
А разве не здорово в Python сделано, может и в динамическую, может и в строгую, если прикажешь?
извиняюсь, я ни разу не программист, но любопытно. неужели нет таких приемчиков, типа "найти, заменить"?
или, грубо говоря, выгрузить текст в эксель, запилить формулу =ЕСЛИ("тупо текст";"STRING(тупо текст);"лети на йух")?
раскрыть ветку (1)
Приёмчики есть, но в том и проблема, что тебе постоянно приходится их использовать и вместо того чтобы просто сложить 2 числа ты должен сначала проверить что в них именно числа либо привести их к числу и только после этого выполнять операцию.
Я все равно ничего не понял, но на всякий случай посмеялся, чтобы не выглядеть глупо.
Ващето не var Text = STRING("тупо текст"), а string Text = "тупо текст". STRING("тупо текст") - это приведение к типу, а динамическая типизация осталась (var).
раскрыть ветку (3)
ещё комментарий
IT-юмор
7.6K поста53.3K подписчика
Правила сообщества
Не публикуем посты:
1) с большим количеством мата
2) с просьбами о помощи
3) не относящиеся к IT-юмору