LINUX.ORG.RU
ФорумTalks

Я тупой, что делать?

 


2

2

Не могу осилить ничего сложнее bash и php, просто не понимаю ЗАЧЕМ!?

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

Почитал новость о том, что в Linux приходит Rust, подумал, ну вот время для изучения C упущено, но сейчас начинается новая эпоха с Rust в ядре, чем чёрт не шутит, может стоит попробовать, авось, для ядра какие-нибудь приколюхи тоже смогу писать? НЕТ НЕ СМОГУ ПОТОМУ ЧТО Я ТУПОЙ(((((

https://doc.rust-lang.ru/book/ch03-01-variables-and-mutability.html#Затенение...

Затенение (переменных)

Я не понимаю что это и зачем это нужно.

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {x}");
    }

    println!("The value of x is: {x}");
}

Почему нельзя из main вызвать функцию, которая сделает это самое x * 2 и напишет строчку, зачем было усложнять и придумывать какое-то { }.

fn main() {
    let x = 5;

    let x = x + 1;

    x_multiple(x);

    println!("The value of x is: {x}");
}

fn x_multiple(x: i32) {
      let x = x * 2;

      println!("The value of x in the inner scope is: {x}");
}

За достоверность синтаксиса не ручаюсь.

Я ещё могу как-то понять типы данных, ну там, один байтик 255 максимальное число, два байтика уже 255 * 255 = 65025 максимальное число, четыре байтика 255 * 255 * 255 * 255... Прикольно конечно, да, что 4 байтами можно кодировать большие числа, как это делают во всяких JPEG, PNG и т.д. бинарных форматах, что можно одним символом " " (пробел) описать число 32 т.к. это 32 символ в ASCII таблице.

Структуры в расте ещё какие-то, почему нельзя обойтись обычными массивами для хранения данных.

Классы в PHP не осилил, Rust похоже тоже не осилю.

Ну и что теперь, обратно в дворники идти?

★★★★★

Последнее исправление: Spoofing (всего исправлений: 1)

Ответ на: комментарий от Spoofing

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

Для программ из 5-6 небольших функций — скорее всего, да, так и будет. :)

Все эти извраты с ООП/АТД и т.д. придуманы для того, чтобы хоть как-то контролировать сложность средних и больших проектов.

Я вот как программист был самоучка. Мне повезло, я в школе начал с мнемокодов ПМК (дали низкий уровень, стек и всё такое) и «Аналитика» МИР-2 (там, наоборот, уровень высокий, но тоже заточенный под инженерные потребности). А потом в институте программировал на чём имеющиеся под рукой компы позволяли. И когда я написал программу на бейсике на 2000 строк (нет, никакого VB тогда не было, обычный бейсик с номерами строк и GOSUB вместо подпрограмм), я сам добровольно перешёл на паскаль. Потому, что понял — для бейсика это потолок.

hobbit ★★★★★
()

Ну и что теперь, обратно в дворники идти?

У тебя есть уникальная возможность лишиться отсрочки, если конечно она у тебя есть и пойти, ну ты понял куда.

peregrine ★★★★★
()
28 мая 2023 г.
Ответ на: комментарий от ergo

Я вот всё читаю этот тред, и поражаюсь тому, как вы все пытаетесь объяснить то, что сами не до конца понимаете.

Shadowing в расте отношение к блокам имеет примерно никакое. При чем сам ТС в посте привел пример по которому это видно. Он за пределами блока делает let x дважды, тем самым ее затеняя без какого-либо создания блока.

 // это две разные переменые в пределах одного блока
 let x = 5; 
 let x = x + 1;

При этом возможность затениния переменных есть во множестве языков. А вот затенения переменных в пределах одной области видимости, или создание областей видимости неявно при затенении, не вводя явно нового блока - это расто-специфичное поведение.

Ровно как и то, что при затенении переменной можно использовать значение из предыдущей привязки. Например код в js

let x = 5
{
   let x = x + 1
}

Выбросит исключение ReferenceError: Cannot access 'x' before initialization

А вот в Расте - это работает.

javascript
()
Ответ на: комментарий от Chord

Сменил баше-портянки на настоящие. Это единственные *тянки, которые ему удалось пощупать.

alex1101
()
Ответ на: комментарий от no-such-file

Я просто изучаю вопрос насколько может быть полезен shadowing идентификаторов в пределах одной области видимости. И перечитываю все треды на всех ресурсах на эту тему.

javascript
()
Ответ на: комментарий от javascript

не понял, чем мой комментарий противоречит вашему смыслу. можете пояснить?

пс я описывал смысл затенения безотносительно растоспецифичности

ergo ★★★
()
Ответ на: комментарий от javascript

Я просто изучаю вопрос насколько может быть полезен shadowing идентификаторов в пределах одной области видимости.

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

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

ergo ★★★
()
Последнее исправление: ergo (всего исправлений: 1)
Ответ на: комментарий от ergo

Тем, что в расте затенение работает и без блоков. А твой ответ описывал это буквально так

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

В расте вообще затенение работает не так, как в большинстве языков (если не во всех). В расте при затенении идентификатора ты можешь использовать его предыдущее значение, в отличии от других языков.

пс я описывал смысл затенения безотносительно растоспецифичности

ТС задал вопрос с конкретными примерами кода, поведение которого твой ответ не объясняет никак.

javascript
()
Ответ на: комментарий от javascript

спасибо за пояснение

В расте при затенении идентификатора ты можешь использовать его предыдущее значение, в отличии от других языков.

можете показать как в примере

let x = 5;

let x = x + 1;

получить доступ к первой х, но после второй х?

любопытно посмотреть на языковую конструкцию такого кейса.

ergo ★★★
()
Последнее исправление: ergo (всего исправлений: 2)
Ответ на: комментарий от ergo

Потому что это не переопределение, а затенение.

let x = 10;
let y = |v| v + x;
let x = 20;
let z = |v| v + x;
println!("{} {}", y(0), z(0)); // 10 20
let x = 0;
let y = &x; 
let x = 1;
let z = &x; 

assert_eq!(*y, 0); // ok
assert_eq!(*z, 1); // ok
javascript
()
Последнее исправление: javascript (всего исправлений: 1)
Ответ на: комментарий от javascript

не хочу показаться грубым, но вы тут смешали теплое и мягкое. ваш трюк с указателем на значение не имеет никакого отношения к затенению.

ergo ★★★
()
Последнее исправление: ergo (всего исправлений: 1)
Ответ на: комментарий от javascript

в этом примере вижу затенение в

let mut y = || { x = x + 1; x };

и переопределение в

let x = 0;

при это оно бесполезное, поскольку далее в коде не используется. уверен, компилятор ее выкинул из код в процессе сборки.

ergo ★★★
()
Ответ на: комментарий от ergo

в этом примере вижу затенение в

Это не затенение, а замыкание. Каждый вызов функции увеличивает значение x на единицу и возвращает его.

и переопределение в

А это не переопределение,а затенение. Потому что идентификатор используется тот же самый. По вашему куда y() сохраняет результаты между вызовами?

при это оно бесполезное, поскольку далее в коде не используется

А в println что выводится?

Ну вот вам еще раз, если вам не очевидно.


let mut x = 0;
let mut y = || { x += 1; x };
let x = "shadow";
let a = y();
let b = y();
let c = y();
println!("a:{} b:{} c:{} x:{}", a, b, c, x); // a:1 b:2 c:3 x:shadow
javascript
()
Последнее исправление: javascript (всего исправлений: 3)
Ответ на: комментарий от javascript

Это не затенение, а замыкание.

мы не обсуждаем вашу конструкцию с замыканием. речь идет о переменной х внутри вашего замыкания. объявление которой и есть «затенение».

А это не переопределение,а затенение. Потому что идентификатор используется тот же самый. По вашему куда y() сохраняет результаты между вызовами?

я даже не буду вам рекомендовать что-то читать на эту тему. вам бы сперва с кашей в терминологии разобраться ибо налицо какое-то самобытное понимание вещей.

еще раз…

let x = 5; <- определение х



    {
        let x = x * 2;<- затенение х
    }
    let x = x + 1; <- переопределение

если вам это неочевидно, непонятно - живите с этим, если так удобнее думать. просто будете попадать в ситуации, когда вас понимать не будут ибо подменяете терминологию.

ergo ★★★
()
Последнее исправление: ergo (всего исправлений: 2)
Ответ на: комментарий от ergo

let mut y = || { x = x + 1; x }; <- затенение х

А вы пробовали определение затенения-то открывать? С каких пор у вас присваивание нового значения переменной стало затенением?

Я вам помогу https://en.wikipedia.org/wiki/Variable_shadowing

Редактировать сообщение после ответа - не большого ума дело.

javascript
()
Последнее исправление: javascript (всего исправлений: 2)
Ответ на: комментарий от javascript

я сначала скопипастил ваш пример, не сразу заметил, что там нет затенения (банальное использование ранее определенной переменной, не понимаю, что именно вы демонстрировали этим примером), поэтому отредактировал и вставил пример от ТС.

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

ergo ★★★
()
Последнее исправление: ergo (всего исправлений: 1)
Ответ на: комментарий от ergo

не понимаю, что именно вы демонстрировали этим примером

Не удивительно. Я вам напомню ваш вопрос Я тупой, что делать? (комментарий)

можете показать как в примере получить доступ к первой х, но после второй х?

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

Но вам это понять не удалось. Просто дело в том, что вы слишком умны для таких вещей.

javascript
()
Последнее исправление: javascript (всего исправлений: 2)
Ответ на: комментарий от ergo

почитайте внимательно статью из вики, которую сами же указали. там все написано. удачи.

Читаю внимательно статью из вики

fn main() {
    let x = 0;
    
    {
        let x = 1;
        println!("Inner x: {}", x); // prints 1
    }
    
    println!("Outer x: {}", x); // prints 0
    
    // Shadow
    let x = "Rust";
    println!("Outer x: {}", x);  // prints 'Rust'
}

Прощайте.

javascript
()
Ответ на: комментарий от javascript

читайте до просветления

In computer programming, variable shadowing occurs when a variable declared within a certain scope (decision block, method, or inner class) has the same name as a variable declared in an outer scope.

has the same name as a variable declared in an outer scope.

in an outer scope.

пример в вики для раста называющий shadow для переопределенной переменной просто некорректен. ибо это подмена смысла shadow.

велкам в игнор.

ergo ★★★
()
Ответ на: комментарий от ergo

Вам просто, как и Спуфу оказалось не по силам понять растовскую концепцую неявного ввода новых областей видимости.

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

О чем я и писал изначально - вы пытаетесь объяснять концепции, которые сами не понимаете. Вы утенок, натягивающий привычные вам вещи на все подряд.

javascript
()
Ответ на: комментарий от javascript

это расто-специфичное поведение

Я может чё-то не понял, но разве во всяких хачкелях не так? Там правда это не совсем переменные.

no-such-file ★★★★★
()
Последнее исправление: no-such-file (всего исправлений: 1)
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.