DEV Community: Kllimenty Karavaev

Тильда (~) в Go: что это и зачем нужно

Kllimenty Karavaev — Tue, 09 Sep 2025 06:46:58 +0000

Привет! Поговорим про оператор ~ в Go, который многих сбивает с толку. Спойлер: это не одна, а целых две разные фичи в зависимости от контекста!

🤔 "Это что за знак такой?"

Видите тильду в Go коде? Не паникуйте! Это либо:

Битовый переворот (чаще всего)
Магия дженериков (в Go 1.18+)

🔄 Битовый NOT: переворачиваем биты

Представьте, что у вас есть число, а тильда просто переворачивает все его биты в двоичном представлении:

x := 5               // 00000101 в двоичной системе счисления
result := ^x         // 11111010 в двоичной системе счисления
fmt.Println(result)  // 250 для uint8, -6 для int8

Простая аналогия: как если бы вы инвертировали цвета в фотошопе — белое становится черным, черное белым.

Где полезно:

Работа с битовыми масками
Шифрование и низкоуровневые операции
Оптимизация памяти

// Пример: проверка бита
const ReadPermission = 1 << 0 // 00000001
const WritePermission = 1 << 1 // 00000010

// Инвертируем маску чтобы получить все КРОМЕ определенных битов
allExceptWrite := ^WritePermission

🎯 Тильда в дженериках: aka "примерно такой тип"

С Go 1.18 тильда получила особое значение в дженериках:

// Ждет именно int
func StrictDouble[T int](x T) T { return x * 2 }

// Принимает любой тип с underlying type int
func FlexibleDouble[T ~int](x T) T { return x * 2 }

type MyInt int

func main() {
    var num MyInt = 5
    FlexibleDouble(num) // ✅ Работает!
    StrictDouble(num)   // ❌ Ошибка компиляции
}

Перевод на человеческий: ~int значит "любой тип, который под капотом является int". Не дискриминирует алиасы :)

💡 Практические советы

Не путайте контексты:
- В выражениях: ^x → битовая операция
- В дженериках: [T ~int] → ограничение типа
Для битовых операций:

   // Включение бита
   flags |= mask

   // Выключение бита
   flags &^= mask  // AND NOT

   // Инверсия битов
   flags = ^flags

В дженериках используйте ~ когда хотите принимать кастомные типы с нужным underlying type.

🚀 Итого

~ — это два разных оператора в одном флаконе
Битовый NOT: переворачиваем биты
Approximation constraint: говорим дженерикам "принимай примерно такие типы"

The lesser known JavaScript features every senior developer should know

Kllimenty Karavaev — Thu, 27 Feb 2025 15:36:31 +0000

JavaScript is amazing and it has a ton of features that might not take the spotlight in your everyday coding but are as cool, useful and important as the rest of them. Besides, if you wanna become a senior developer, learning about every little detail about your porgramming language of choice is definitely a way to go. Let's dive in!

The optional chaining operator

I know what you're thinking, I already know this one! And I mean sure, if you've been a JavaScript developer longer than like a few weeks you've probably come across the optional chaining operator many times as it is very helpful and widely adopted in most modern-day projects. However, this operator has more to offer than what can seem at first glance because not only you can use it to access non-existing properties on types that may not even be objects but you can also use it in combination with functions that may or may not be defined. Consider the following TypeScript code.

function notSoCoolFunction(someCallback?: () => void) {
  if(someCallback) {
    someCallback();
  }
}

function veryCoolFunction(someCallback?: () => void) {
  someCallback?.();
}

Here we have two differently named functions that execute pretty much the same code. The only difference is that in notSoCoolFunction, we have to explicitly run a check if the someCallback was indeed provided as an argument, whereas veryCoolFunction doesn't make any explicit runtime checks to determine if we've been provided a callback function or not. It simply calls the optional someCallback function utilizing the optional chaining operator syntax.

As you might have noticed, the syntax is much shorter and readable as we don't have to make any assertions about whether this optional someCallback argument is omitted or not. Of course, that doesn't affect the correctness of our program's execution because if the someCallback is omitted, the JS engine will simply continue to execute other code, and no runtime errors like TypeError will be thrown. Pretty neat don't you think?

You can find more about it here

The `new.target` meta-property

Here's something 98% of JavaScript developers have never even seen being used as it is rather an old feature introduced in some of the earlier versions of ECMAScript, rarely applicable unless you're doing some very obscure OOP magic in your code.

Here's what it is: new.target is a meta-property that lets you detect whether a function or constructor was called using the new operator. In constructors and functions invoked using the new operator, new.target returns a reference to the constructor or function that new was called upon. In normal function calls, new.target is undefined.

The new.target syntax consists of the keyword new, a dot, and the identifier target. Because new is a reserved word, not an identifier, this is not a property accessor, but a special expression syntax.

The new.target meta-property is available in all function/class bodies; using new.target outside of functions or classes is a syntax error.

One practical example of how it can be used is checking whether a function is called as a constructor or as a regular function:

function Foo() {
  if (!new.target) {
    throw new TypeError("calling Foo constructor without new is invalid");
  }
}

try {
  Foo();
} catch (e) {
  console.log(e);
  // Expected output: TypeError: calling Foo constructor without new is invalid
}

You can read more about it here

The void operator

Alright then, let's finish off with yet another lesser-known JavaScript feature that can be quite handy in certain situations: the void operator. This operator is used to discard the return value of an expression, effectively returning undefined. It's particularly useful when you want to evaluate an expression for its side effects but don't care about its return value.

Let's start with a simple example:

console.log(void 42); // Outputs: undefined

In this example, the void operator discards the value 42, resulting in undefined.

Now, let's dive into a more practical use case involving IIFEs (Immediately Invoked Function Expressions). Sometimes, you might want to execute a function immediately without leaving any trace of its return value. Here's how you can do it:

void function iifeExample() {
  console.log("This function runs immediately!");
  return "You won't see this!";
}();

In this example, the IIFE iifeExample is executed immediately upon definition. The void operator ensures that the return value of the function is discarded, so even though the function returns a string, it won't be used or stored anywhere. This can be useful in scenarios where you want to run some initialization code without polluting the global scope with unnecessary return values.

The void operator is a neat tool to have in your JavaScript toolkit, allowing you to write cleaner and more intentional code, especially when dealing with expressions where the return value is not needed.