Исправление TypeError: объект 'float' не может быть вызван в Python

Одна ошибка, с которой вы можете столкнуться при работе с Python:

TypeError: 'float' object is not callable

Эта ошибка возникает, когда вы по ошибке вызываете floatобъект, как если бы он был функцией.

Следующий код является примером, который вызывает эту ошибку:

5.555()

Существует три возможных сценария, вызывающих эту ошибку:

1. Вы пытаетесь умножить число с плавающей запятой без добавления *оператора
2. Вы переопределяете float()функцию с помощью объекта с плавающей запятой
3. У вас есть функция и переменная с плавающей запятой с тем же именем

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

1. Вы пытаетесь умножить число с плавающей запятой без добавления *оператора

Во-первых, вы объявили простую переменную с плавающей запятой следующим образом:

my_float = 7.2

Затем вы пытаетесь умножить переменную с плавающей запятой на число, полученное в результате математических операций, следующим образом:

x = my_float(5 - 2)

Выход:

Traceback (most recent call last):
  File "main.py", line 3, in <module>
    x = my_float(5 - 2)
        ^^^^^^^^^^^^^^^
TypeError: 'float' object is not callable

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

Хотя приведенная выше формула умножения действительна в реальной жизни, это заставляет Python думать, что вы пытаетесь вызвать функцию с именем, my_float()а не пытаетесь выполнить умножение.

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

Поскольку вы хотите умножить переменную, добавьте оператор умножения *следующим образом:

my_float = 7.2

x = my_float * (5 - 2)

print(x)  # 21.6

На этот раз умножение прошло успешно, и мы не получили ошибки.

2. Вы переопределяете float()функцию с помощью объекта с плавающей запятой

Встроенная функция named float()используется для преобразования объекта другого типа в объект с плавающей запятой.

Например, вот как преобразовать строку в число с плавающей запятой:

my_string = "7.55"

my_float = float(my_string)
print(my_float)  # 7.55

Если вы по ошибке создадите переменную с именем float, функция float()будет перезаписана.

При вызове float()функции ошибка будет выглядеть следующим образом:

float = 3.45

another_float = float("7.55")

Выход:

Traceback (most recent call last):
  File "/main.py", line 3, in <module>
    another_float = float("7.55")
                    ^^^^^^^^^^^^^
TypeError: 'float' object is not callable

Поскольку вы создали переменную с именем float, float()функция заменяется этой переменной, что приводит к вызову объекта с плавающей запятой вместо встроенной функции.

Чтобы избежать этой ошибки, вам нужно объявить переменную, используя другое имя:

my_float = 3.45  # ✅

another_float = float("7.55")

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

У вас есть функция и переменная с плавающей запятой с тем же именем

Предположим, у вас есть функция с именем get_name(), которая возвращает строку следующего вида:

def get_name():
    return "Nathan"

Затем в строке вы объявили переменную, используя get_nameв качестве идентификатора:

get_name = 7.67

Это приводит к тому, что get_nameпеременная затеняет get_name()функцию. Когда вы пытаетесь вызвать функцию, Python думает, что вместо этого вы вызываете переменную:

def get_name():
    return "Nathan"

get_name = 7.67

res = get_name()  # TypeError: 'float' object is not callable

Чтобы устранить эту ошибку, убедитесь, что в исходном коде нет повторяющихся имен.

Каждая функция и переменная должны иметь уникальное имя:

def get_name():
    return "Nathan"

x = 7.67

res = get_name()  # ✅

Теперь, когда имя функции и переменной уникальны, мы не получили никакой ошибки.

Заключение

Это TypeError: 'float' object is not callableпроисходит в Python, когда вы вызываете объект с плавающей запятой, используя круглые скобки, как будто это функция.

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

Я надеюсь, что это руководство поможет. Удачного кодирования!

Оригинальный источник статьи: https://sebhastian.com/

#python #object #typeerror 

修复 TypeError：'float' 对象在 Python 中不可调用

使用 Python 时可能遇到的一个错误是：

TypeError: 'float' object is not callable

float当您错误地将对象当作函数来调用时，就会发生此错误。

以下代码是导致此错误的示例：

5.555()

导致此错误的可能情况有以下三种：

1. *您尝试在不添加运算符的情况下乘以浮点数
2. 你float()用一个浮点对象覆盖这个函数
3. 你有一个同名的函数和一个浮点变量

本教程展示了如何在每种情况下重现错误以及如何修复错误。

1. 你试图在不添加*运算符的情况下乘以一个浮点数

首先，您声明了一个简单的 float 变量，如下所示：

my_float = 7.2

接下来，您尝试将 float 变量与从数学运算中获取的数字相乘，如下所示：

x = my_float(5 - 2)

输出：

Traceback (most recent call last):
  File "main.py", line 3, in <module>
    x = my_float(5 - 2)
        ^^^^^^^^^^^^^^^
TypeError: 'float' object is not callable

发生错误是因为您在浮动对象旁边添加了括号。

虽然上面是现实生活中有效的乘法公式，但这会让 Python 认为您正在尝试调用一个名为的函数，my_float()而不是尝试进行乘法。

要解决此错误，您需要确保没有在浮动对象旁边添加括号。

由于要乘以变量，请*按如下方式添加乘法运算符：

my_float = 7.2

x = my_float * (5 - 2)

print(x)  # 21.6

这次，乘法成功了，我们没有收到错误。

2. 你float()用一个浮点对象覆盖这个函数

内置函数 namedfloat()用于将另一种类型的对象转换为 float 对象。

例如，以下是将字符串转换为浮点数的方法：

my_string = "7.55"

my_float = float(my_string)
print(my_float)  # 7.55

如果您错误地创建了一个名为 的变量float，那么该float()函数将被覆盖。

当您调用该float()函数时，会出现如下错误：

float = 3.45

another_float = float("7.55")

输出：

Traceback (most recent call last):
  File "/main.py", line 3, in <module>
    another_float = float("7.55")
                    ^^^^^^^^^^^^^
TypeError: 'float' object is not callable

因为您创建了一个名为 的变量float，该float()函数将被该变量替换，导致您调用一个浮点对象而不是内置函数。

为避免此错误，您需要使用其他名称声明变量：

my_float = 3.45  # ✅

another_float = float("7.55")

这样，关键字float仍然指向 float 函数，并且不会引发错误。

你有一个同名的函数和一个浮点变量

假设您有一个名为的函数get_name()返回一个字符串，如下所示：

def get_name():
    return "Nathan"

然后，您声明了一个用作get_name标识符的变量：

get_name = 7.67

这导致get_name变量隐藏函数get_name()。当您尝试调用函数时，Python 认为您正在调用变量：

def get_name():
    return "Nathan"

get_name = 7.67

res = get_name()  # TypeError: 'float' object is not callable

要解决此错误，请确保您的源代码中没有重复的名称。

每个函数和变量必须有一个唯一的名字：

def get_name():
    return "Nathan"

x = 7.67

res = get_name()  # ✅

现在函数和变量的名称是唯一的，我们没有收到任何错误。

结论

TypeError: 'float' object is not callable当您像调用函数一样使用括号调用浮点对象时，会在 Python 中发生这种情况。

要解决此错误，您需要确保没有在源代码中调用浮点对象。

我希望本教程有所帮助。编码愉快！

原始文章来源：https: //sebhastian.com/

#python #object #typeerror 

Исправить TypeError: объект 'int' не может быть вызван в Python

Одна ошибка, с которой вы можете столкнуться при работе с Python:

TypeError: 'int' object is not callable

Эта ошибка возникает, когда вы по ошибке вызываете целочисленный ( int) объект, как если бы это была функция.

Следующий код является примером, который вызывает эту ошибку:

900()

Существует три возможных сценария, вызывающих эту ошибку:

1. Вы пытаетесь умножить целое число без добавления *оператора
2. Вы переопределяете int()функцию с помощью объекта int
3. У вас есть функция и целочисленная переменная с одинаковым именем

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

1. Вы пытаетесь умножить целое без добавления *оператора

Во-первых, вы объявили простую переменную типа int следующим образом:

my_int = 30

Затем вы пытаетесь умножить переменную int на число, полученное в результате математических операций, следующим образом:

x = my_int(5 - 2)

Выход:

Traceback (most recent call last):
  File "main.py", line 3, in <module>
    x = my_int(5 - 2)
        ^^^^^^^^^^^^^^^
TypeError: 'int' object is not callable

Ошибка возникает из-за того, что вы добавляете круглые скобки рядом с intобъектом.

Хотя приведенная выше формула умножения действительна в реальной жизни, это заставляет Python думать, что вы пытаетесь вызвать функцию с именем, my_int()а не пытаетесь выполнить умножение.

Чтобы устранить эту ошибку, вам нужно убедиться, что вы не добавляете круглые скобки рядом с объектом типа int.

Поскольку вы хотите умножить переменную, добавьте оператор умножения *следующим образом:

my_int = 30

x = my_int * (5 - 2)

print(x)  # 90

На этот раз умножение прошло успешно, и мы не получили ошибки.

2. Вы переопределяете int()функцию с помощью объекта int

Встроенная функция named int()используется для преобразования объекта другого типа в объект типа int.

Например, вот как преобразовать строку в int:

my_string = "0385"

my_int = int(my_string)
print(my_int)  # 385

Если вы по ошибке создадите переменную с именем int, функция int()будет перезаписана.

При вызове int()функции ошибка будет выглядеть следующим образом:

int = 44

another_int = int("0385")

Выход:

Traceback (most recent call last):
  File "/main.py", line 3, in <module>
    another_int = int("0385")
                  ^^^^^^^^^^^
TypeError: 'int' object is not callable

Поскольку вы создали переменную с именем int, int()функция заменяется этой переменной, что приводит к вызову объекта int вместо встроенной функции.

Чтобы избежать этой ошибки, вам нужно объявить переменную, используя другое имя:

my_int = 44  # ✅

another_int = int("0385")

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

У вас есть функция и целочисленная переменная с одинаковым именем

Предположим, у вас есть функция с именем get_name(), которая возвращает строку следующего вида:

def get_name():
    return "Nathan"

Затем в строке вы объявили переменную, используя get_nameв качестве идентификатора:

get_name = 867

Это приводит к тому, что get_nameпеременная затеняет get_name()функцию. Когда вы пытаетесь вызвать функцию, Python думает, что вместо этого вы вызываете переменную:

def get_name():
    return "Nathan"

get_name = 867

res = get_name()  # TypeError: 'int' object is not callable

Чтобы устранить эту ошибку, убедитесь, что в исходном коде нет повторяющихся имен.

Каждая функция и переменная должны иметь уникальное имя:

def get_name():
    return "Nathan"

x = 867

res = get_name()  # ✅

Теперь, когда имя функции и переменной уникальны, мы не получили никакой ошибки.

Заключение

Это TypeError: 'int' object is not callableпроисходит в Python, когда вы вызываете объект int с помощью круглых скобок, как будто это функция.

Чтобы устранить эту ошибку, вам нужно убедиться, что вы не вызываете объект int в исходном коде.

Я надеюсь, что это руководство поможет. Удачного кодирования!

Оригинальный источник статьи: https://sebhastian.com/

#python #typeerror #object 

Fix TypeError: 'float' Object is Not Callable in Python

One error that you might encounter when working with Python is:

TypeError: 'float' object is not callable

This error occurs when you mistakenly call a float object as if it was a function.

The following code is an example that causes this error:

5.555()

There are three possible scenarios that cause this error:

1. You attempt to multiply a float without adding the * operator
2. You override the float() function with a float object
3. You have a function and a float variable with the same name

This tutorial shows how to reproduce the error in each scenario and how to fix it.

1. You attempt to multiply a float without adding the * operator

First, you declared a simple float variable as follows:

my_float = 7.2

Next, you attempt to multiply the float variable with a number acquired from math operations as follows:

x = my_float(5 - 2)

Output:

Traceback (most recent call last):
  File "main.py", line 3, in <module>
    x = my_float(5 - 2)
        ^^^^^^^^^^^^^^^
TypeError: 'float' object is not callable

The error occurs because you’re adding parentheses next to a float object.

While the above is a valid multiplication formula in real life, this makes Python thinks you’re trying to call a function named my_float() instead of trying to do a multiplication.

To resolve this error, you need to make sure that you’re not adding parentheses next to a float object.

Since you want to multiply the variable, add the multiplication operator * as follows:

my_float = 7.2

x = my_float * (5 - 2)

print(x)  # 21.6

This time, the multiplication succeeds and we didn’t receive an error.

2. You override the float() function with a float object

The built-in function named float() is used to convert an object of another type into a float object.

For example, here’s how to convert a string into a float:

my_string = "7.55"

my_float = float(my_string)
print(my_float)  # 7.55

If you mistakenly create a variable named float, then the float() function would be overwritten.

When you call the float() function, the error would occur as follows:

float = 3.45

another_float = float("7.55")

Output:

Traceback (most recent call last):
  File "/main.py", line 3, in <module>
    another_float = float("7.55")
                    ^^^^^^^^^^^^^
TypeError: 'float' object is not callable

Because you created a variable named float, the float() function gets replaced with that variable, causing you to call a float object instead of the built-in function.

To avoid this error, you need to declare the variable using another name:

my_float = 3.45  # ✅

another_float = float("7.55")

This way, the keyword float would still point to the float function, and the error won’t be raised.

You have a function and a float variable with the same name

Suppose you have a function named get_name() that returns a string as follows:

def get_name():
    return "Nathan"

Then down the line, you declared a variable using get_name as the identifier:

get_name = 7.67

This cause the get_name variable to shadow the get_name() function. When you try to call the function, Python thinks you’re calling the variable instead:

def get_name():
    return "Nathan"

get_name = 7.67

res = get_name()  # TypeError: 'float' object is not callable

To resolve this error, make sure that there’s no duplicate name in your source code.

Each function and variable must have a unique name:

def get_name():
    return "Nathan"

x = 7.67

res = get_name()  # ✅

Now that the name for the function and the variable are unique, we didn’t receive any error.

Conclusion

The TypeError: 'float' object is not callable occurs in Python when you call a float object using parentheses like it’s a function.

To resolve this error, you need to make sure that you’re not calling a float object in your source code.

I hope this tutorial helps. Happy coding!

Original article source at: https://sebhastian.com/

#python #object #typeerror 

修复 TypeError：'int' 对象在 Python 中不可调用

使用 Python 时可能遇到的一个错误是：

TypeError: 'int' object is not callable

当您错误地将整数 ( int) 对象当作函数来调用时，就会发生此错误。

以下代码是导致此错误的示例：

900()

导致此错误的可能情况有以下三种：

1. *您尝试在不添加运算符的情况下乘以一个整数
2. 你int()用一个 int 对象覆盖函数
3. 你有一个同名的函数和一个整型变量

本教程展示了如何在每种情况下重现错误以及如何修复错误。

1. 你试图在不添加*运算符的情况下乘以一个 int

首先，您声明了一个简单的 int 变量，如下所示：

my_int = 30

接下来，您尝试将 int 变量与从数学运算中获取的数字相乘，如下所示：

x = my_int(5 - 2)

输出：

Traceback (most recent call last):
  File "main.py", line 3, in <module>
    x = my_int(5 - 2)
        ^^^^^^^^^^^^^^^
TypeError: 'int' object is not callable

发生错误是因为您在int对象旁边添加了括号。

虽然上面是现实生活中有效的乘法公式，但这会让 Python 认为您正在尝试调用一个名为的函数，my_int()而不是尝试进行乘法。

要解决此错误，您需要确保没有在 int 对象旁边添加括号。

由于要乘以变量，请*按如下方式添加乘法运算符：

my_int = 30

x = my_int * (5 - 2)

print(x)  # 90

这次，乘法成功了，我们没有收到错误。

int()2.用一个 int 对象覆盖函数

内置函数 namedint()用于将另一种类型的对象转换为 int 对象。

例如，以下是将字符串转换为 int 的方法：

my_string = "0385"

my_int = int(my_string)
print(my_int)  # 385

如果您错误地创建了一个名为 的变量int，那么该int()函数将被覆盖。

当您调用该int()函数时，会出现如下错误：

int = 44

another_int = int("0385")

输出：

Traceback (most recent call last):
  File "/main.py", line 3, in <module>
    another_int = int("0385")
                  ^^^^^^^^^^^
TypeError: 'int' object is not callable

因为您创建了一个名为 的变量int，该int()函数将被该变量替换，导致您调用一个 int 对象而不是内置函数。

为避免此错误，您需要使用其他名称声明变量：

my_int = 44  # ✅

another_int = int("0385")

这样，关键字int仍然指向 int 函数，并且不会引发错误。

你有一个同名的函数和一个整型变量

假设您有一个名为的函数get_name()返回一个字符串，如下所示：

def get_name():
    return "Nathan"

然后，您声明了一个用作get_name标识符的变量：

get_name = 867

这导致get_name变量隐藏函数get_name()。当您尝试调用函数时，Python 认为您正在调用变量：

def get_name():
    return "Nathan"

get_name = 867

res = get_name()  # TypeError: 'int' object is not callable

要解决此错误，请确保您的源代码中没有重复的名称。

每个函数和变量必须有一个唯一的名字：

def get_name():
    return "Nathan"

x = 867

res = get_name()  # ✅

现在函数和变量的名称是唯一的，我们没有收到任何错误。

结论

TypeError: 'int' object is not callable当您像调用函数一样使用括号调用 int 对象时，会在 Python 中发生这种情况。

要解决此错误，您需要确保您没有在源代码中调用 int 对象。

我希望本教程有所帮助。编码愉快！

原始文章来源：https: //sebhastian.com/

#python #typeerror #object 

Fix TypeError: 'int' Object is Not Callable in Python

One error that you might encounter when working with Python is:

TypeError: 'int' object is not callable

This error occurs when you mistakenly call an integer (int) object as if it was a function.

The following code is an example that causes this error:

900()

There are three possible scenarios that cause this error:

1. You attempt to multiply an integer without adding the * operator
2. You override the int() function with an int object
3. You have a function and an integer variable with the same name

This tutorial shows how to reproduce the error in each scenario and how to fix it.

1. You attempt to multiply an int without adding the * operator

First, you declared a simple int variable as follows:

my_int = 30

Next, you attempt to multiply the int variable with a number acquired from math operations as follows:

x = my_int(5 - 2)

Output:

Traceback (most recent call last):
  File "main.py", line 3, in <module>
    x = my_int(5 - 2)
        ^^^^^^^^^^^^^^^
TypeError: 'int' object is not callable

The error occurs because you’re adding parentheses next to an int object.

While the above is a valid multiplication formula in real life, this makes Python thinks you’re trying to call a function named my_int() instead of trying to do a multiplication.

To resolve this error, you need to make sure that you’re not adding parentheses next to an int object.

Since you want to multiply the variable, add the multiplication operator * as follows:

my_int = 30

x = my_int * (5 - 2)

print(x)  # 90

This time, the multiplication succeeds and we didn’t receive an error.

2. You override the int() function with an int object

The built-in function named int() is used to convert an object of another type into an int object.

For example, here’s how to convert a string into an int:

my_string = "0385"

my_int = int(my_string)
print(my_int)  # 385

If you mistakenly create a variable named int, then the int() function would be overwritten.

When you call the int() function, the error would occur as follows:

int = 44

another_int = int("0385")

Output:

Traceback (most recent call last):
  File "/main.py", line 3, in <module>
    another_int = int("0385")
                  ^^^^^^^^^^^
TypeError: 'int' object is not callable

Because you created a variable named int, the int() function gets replaced with that variable, causing you to call an int object instead of the built-in function.

To avoid this error, you need to declare the variable using another name:

my_int = 44  # ✅

another_int = int("0385")

This way, the keyword int would still point to the int function, and the error won’t be raised.

You have a function and an integer variable with the same name

Suppose you have a function named get_name() that returns a string as follows:

def get_name():
    return "Nathan"

Then down the line, you declared a variable using get_name as the identifier:

get_name = 867

This cause the get_name variable to shadow the get_name() function. When you try to call the function, Python thinks you’re calling the variable instead:

def get_name():
    return "Nathan"

get_name = 867

res = get_name()  # TypeError: 'int' object is not callable

To resolve this error, make sure that there’s no duplicate name in your source code.

Each function and variable must have a unique name:

def get_name():
    return "Nathan"

x = 867

res = get_name()  # ✅

Now that the name for the function and the variable are unique, we didn’t receive any error.

Conclusion

The TypeError: 'int' object is not callable occurs in Python when you call an int object using parentheses like it’s a function.

To resolve this error, you need to make sure that you’re not calling an int object in your source code.

I hope this tutorial helps. Happy coding!

Original article source at: https://sebhastian.com/

#python #typeerror #object 

Проверьте, существует ли ключ в объекте/массиве JavaScript

Введение

Объект в JavaScript — это неупорядоченный набор пар ключ-значение ( key: value). Каждый ключ известен как свойство и представляет собой строку, представляющую имя свойства. Если в качестве ключа задано нестроковое значение, будет использоваться его строковое представление. Значением свойства может быть любой тип данных, концептуально соответствующий свойству, — строка, число, массив или даже функция.

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

При работе с JavaScript вам может в определенный момент времени понадобиться определить, существует ли ключ в данном объекте или массиве.

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

Использование inоператора

Оператор inв JavaScript используется для определения того, существует ли определенное свойство в объекте или его унаследованных свойствах (также называемых цепочкой прототипов). Если указанное свойство существует, inоператор возвращает значение true.

Проверка объекта

let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};
  
// Check if key exists
  
'name' in user; // Returns true
'profession' in user; // Returns true
'Daniel' in user; // Returns false becuase no key like that exists
'Farmer' in user; // Returns false because 'Farmer' is not a key, but a value

Проверка массива

Поскольку мы продемонстрировали, что оператор JavaScript inможно использовать с объектами, вы можете спросить, можно ли его также использовать с массивами. В JavaScript все является экземпляром типа Object (кроме примитивов), поэтому массивы также поддерживают оператор in.

Давайте подтвердим, является ли это экземпляром типа, Objectиспользуя instanceofоператор:

let numbers = [22, 3, 74, 35];
  
numbers instanceof Object // Returns true

Теперь вернемся к использованию inоператора:

let numbers = [12, 33, 14, 45, 6];

// Checking if index 1 is present
1 in numbers; // Returns true
// Checking if index 3 is present
3 in numbers; // Returns true

8 in numbers; // Returns false because the 8 index does exist in the array 
6 in numbers; // Returns false because the 6 index does not exist in the array

Это также вернет trueсвойства метода для типа массива, экземпляром которого является числовой массив.

'map' in number; // Returns true because 'map' is a method attribute of the array type

Использование hasOwnProperty()метода

В JavaScript hasOwnProperty()функция используется для определения того, имеет ли объект предоставленное свойство как собственное свойство. Это важно для определения того, унаследован ли атрибут объектом, а не является ли он его собственным.

Проверка объекта

let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};
  
// Check if key exists
let hasKey = user.hasOwnProperty('name'); 
  
if (hasKey) {
    console.log('This key exists.');
} else {
    console.log('This key does not exist.');
}

Проверка массива

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

let number = [12, 33, 14, 45];

// Check if key exists
number.hasOwnProperty(1); // Returns true
number.hasOwnProperty(0); // Returns true
number.hasOwnProperty(7); // Returns false because 7 is not an existing index on the array

Использование Object.key()метода

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

Использование some()метода

some()— это метод JavaScript, который проверяет функцию обратного вызова на всех элементах вызывающего массива и возвращает значение, trueесли функция обратного вызова возвращает значение trueдля любого из них.

Использование some()для объектов

let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};
  
// Check if key exists
Object.keys(user).some(key => key === 'name'); // Returns true
Object.keys(user).some(key => key === 'role'); // Returns false

Мы также можем превратить это в повторно используемую функцию:

const checkKey = (obj, keyName) => {
    let keyExist = Object.keys(obj).some(key => key === keyName);
    console.log(keyExist);
};
  
checkKey(user, 'name'); // Return true

Использование some()для массива

let number = [12, 33, 14, 45];
    
// Check if key exists
number.some(value => value === 1); // Returns true
number.some(value => value === 7); // Returns false

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

const checkVal = (arr, val) => {
    let valExist = arr.some(value => value === val);
    console.log(valExist);
};

checkVal(number, 7); // Returns false
checkVal(number, 0); // Returns true

Использование indexOf()метода

Метод JavaScript indexOf()вернет индекс первого экземпляра элемента в массиве. Если элемент не существует, возвращается -1.

Использование indexOf()для объекта

Тип Objectв JavaScript на самом деле не поддерживает этот indexOfметод, поскольку его свойства/ключи по своей сути не имеют индексированных позиций в объекте. Вместо этого мы можем получить ключи объекта в виде массива, а затем проверить наличие ключа с помощью метода indexOf:

let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};

// Check if key exists
Object.keys(user).indexOf('name') // Returns 0
Object.keys(user).indexOf('role') // Returns -1

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

Вот пример использования этого в служебной функции:

const checkKey = (obj, keyName) => {
    if (Object.keys(obj).indexOf(keyName) !== -1) {
        console.log('This key exists');
    } else {
        console.log('This key does not exist');
    }
};
  
checkKey(user, 'name'); // Logs 'This key exists'
checkKey(user, 'role'); // Logs 'This key does not exists'

Использование indexOf()для массива

Как мы видели в предыдущем примере, массивы поддерживают этот indexOfметод, в отличие от объектов. Чтобы использовать его, передайте значение искомого элемента в indexOf, который затем вернет позицию этого значения, если оно существует в массиве:

let number = [12, 33, 14, 45];
    
// Find position of the item in the array
number.indexOf(14); // Returns 2
number.indexOf(7);  // Returns -1

Заключение

В этой статье мы рассмотрели все возможные способы проверки существования ключа или элемента в объекте/массиве JavaScript. Мы покажем, как использовать inоператор, hasOwnProperty()метод и someметод. Мы также видели, как объекты и массивы JS похожи в том, что массивы наследуются от объектов и, таким образом, содержат многие из тех же методов.

Оригинальный источник статьи по адресу:   https://stackabuse.com/

#javascript #object #array 

检查 JavaScript 对象/数组中是否存在键

介绍

JavaScript 中的对象是键值对 ( key: value) 的无序集合。每个键都称为property，并且是表示属性名称的字符串。如果给定一个非字符串作为键，将使用它的字符串化表示。属性的值可以是概念上适合该属性的任何数据类型 - 字符串、数字、数组，甚至是函数。

另一方面，数组是一组经过排序的值。每个值都称为一个元素，由数字索引标识。数组可以包含几乎任何类型的值。例如，它可以存储整数、字符串、布尔值、函数等项目。JavaScript 数组也不限于单一类型，这意味着给定的数组可以包含多种不同的类型。

在 JavaScript 中工作时，您可能会在特定时间点需要确定给定对象或数组中是否存在某个键。

在本文中，我们将看到可用于检查 JavaScript 对象/数组中是否存在特定键的各种方法。

使用in操作员

JavaScript 中的运算符in用于确定对象或其继承属性（也称为其原型链）中是否存在某个属性。如果提供的属性存在，则in运算符返回 true。

检查对象

let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};
  
// Check if key exists
  
'name' in user; // Returns true
'profession' in user; // Returns true
'Daniel' in user; // Returns false becuase no key like that exists
'Farmer' in user; // Returns false because 'Farmer' is not a key, but a value

检查数组

由于我们演示了 JavaScriptin运算符可以与对象一起使用，您可能会问它是否也可以与数组一起使用。在 JavaScript 中，一切都是 Object 类型的实例（原始类型除外），因此数组也支持in运算符。

让我们确认它是否是Object使用instanceof运算符的类型的实例：

let numbers = [22, 3, 74, 35];
  
numbers instanceof Object // Returns true

现在，回到使用in运算符：

let numbers = [12, 33, 14, 45, 6];

// Checking if index 1 is present
1 in numbers; // Returns true
// Checking if index 3 is present
3 in numbers; // Returns true

8 in numbers; // Returns false because the 8 index does exist in the array 
6 in numbers; // Returns false because the 6 index does not exist in the array

这也将返回true数组类型的方法属性，其中数字数组是一个实例。

'map' in number; // Returns true because 'map' is a method attribute of the array type

使用hasOwnProperty()方法

在 JavaScript 中，该hasOwnProperty()函数用于确定对象是否将提供的属性作为其自身的属性。这对于确定属性是否由对象继承而不是它自己的属性很重要。

检查对象

let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};
  
// Check if key exists
let hasKey = user.hasOwnProperty('name'); 
  
if (hasKey) {
    console.log('This key exists.');
} else {
    console.log('This key does not exist.');
}

检查数组

您可能会开始怀疑这是否适用于数组。正如我们之前建立的，数组实际上是类型的原型（实例）Object，因此它也可以使用此方法。

let number = [12, 33, 14, 45];

// Check if key exists
number.hasOwnProperty(1); // Returns true
number.hasOwnProperty(0); // Returns true
number.hasOwnProperty(7); // Returns false because 7 is not an existing index on the array

使用Object.key()方法

静态方法Object.key生成并返回一个数组，其组件是对象属性名称（键）的字符串。这可用于遍历对象的键，然后我们可以使用这些键来验证是否有任何匹配对象中的某个键。

使用some()方法

some()是一个 JavaScript 方法，它在调用数组的所有元素上测试回调函数，true如果回调函数返回true其中任何一个，则返回。

用于some()对象

let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};
  
// Check if key exists
Object.keys(user).some(key => key === 'name'); // Returns true
Object.keys(user).some(key => key === 'role'); // Returns false

我们还可以将其自定义为可重用的函数：

const checkKey = (obj, keyName) => {
    let keyExist = Object.keys(obj).some(key => key === keyName);
    console.log(keyExist);
};
  
checkKey(user, 'name'); // Return true

用于some()数组

let number = [12, 33, 14, 45];
    
// Check if key exists
number.some(value => value === 1); // Returns true
number.some(value => value === 7); // Returns false

同样，就像对象一样，我们也可以使用类似的自定义可重用函数来检查数组中是否存在值：

const checkVal = (arr, val) => {
    let valExist = arr.some(value => value === val);
    console.log(valExist);
};

checkVal(number, 7); // Returns false
checkVal(number, 0); // Returns true

使用indexOf()方法

JavaScript 的方法将返回数组中元素的第一个实例indexOf()的索引。如果该元素不存在，则返回 -1。

用于indexOf()对象

JavaScript 中的类型Object实际上并不支持该indexOf方法，因为它的属性/键在对象中没有固有的索引位置。相反，我们可以将对象的键作为数组获取，然后使用以下方法检查键是否存在indexOf：

let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};

// Check if key exists
Object.keys(user).indexOf('name') // Returns 0
Object.keys(user).indexOf('role') // Returns -1

请记住，JavaScript 对象并不总是保留键顺序，因此返回的索引可能不像在数组中那样有意义。在这种情况下，索引应该主要用于确定键的存在。

下面是在效用函数中使用它的示例：

const checkKey = (obj, keyName) => {
    if (Object.keys(obj).indexOf(keyName) !== -1) {
        console.log('This key exists');
    } else {
        console.log('This key does not exist');
    }
};
  
checkKey(user, 'name'); // Logs 'This key exists'
checkKey(user, 'role'); // Logs 'This key does not exists'

用于indexOf()数组

正如我们在前面的示例中看到的，与indexOf对象不同，数组确实支持该方法。要使用它，请将您要查找的项目的值传递给indexOf，如果该值存在于数组中，它将返回该值的位置：

let number = [12, 33, 14, 45];
    
// Find position of the item in the array
number.indexOf(14); // Returns 2
number.indexOf(7);  // Returns -1

结论

在本文中，我们已经了解了检查 JavaScript 对象/数组中是否存在键或项的所有可能方法。我们展示了如何使用运算in符、hasOwnProperty()方法和some方法。我们还看到了 JS 对象和数组的相似之处在于数组继承自对象，因此包含许多相同的方法。

原始文章来源：https:   //stackabuse.com/

#javascript #object #array 

Check if Key Exists in JavaScript Object/Array

Introduction

An object in JavaScript is an unordered collection of key-value pairs (key: value). Each key is known as a property, and is a string representing a property name. If a non-string is given as the key, it's stringified representation will be used. A property's value can be of any data type that fits the property conceptually - a string, a number, an array, or even a function.

An array, on the other hand, is a sorted set of values. Each value is referred to as an element, which is identified by a numerical index. An array can include values of almost any type. For example, it can store items like integers, strings, booleans, functions, etc. JavaScript arrays are also not restricted to a single type, meaning a given array can contain multiple different types within it.

When working in JavaScript, you might at a particular point in time need to determine if a key exists in a given object or array.

In this article, we will see the various methods which we could use to check if a particular key exists in a JavaScript object/array.

Using the in Operator

The in operator in JavaScript is used to determine if a certain property exists in an object or its inherited properties (also known as its prototype chain). If the provided property exists, the in operator returns true.

Checking an Object

let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};
  
// Check if key exists
  
'name' in user; // Returns true
'profession' in user; // Returns true
'Daniel' in user; // Returns false becuase no key like that exists
'Farmer' in user; // Returns false because 'Farmer' is not a key, but a value

Checking an Array

Since we demonstrated that the JavaScript in operator can be used with objects, you may be asking if it can also be used with arrays. In JavaScript, everything is an instance of the Object type (except for primitives), so arrays also support the in operator.

Let's confirm if it's an instance of the Object type using the instanceof operator:

let numbers = [22, 3, 74, 35];
  
numbers instanceof Object // Returns true

Now, back to using the in operator:

let numbers = [12, 33, 14, 45, 6];

// Checking if index 1 is present
1 in numbers; // Returns true
// Checking if index 3 is present
3 in numbers; // Returns true

8 in numbers; // Returns false because the 8 index does exist in the array 
6 in numbers; // Returns false because the 6 index does not exist in the array

This will also return true for method properties on an array type, of which the number array is an instance.

'map' in number; // Returns true because 'map' is a method attribute of the array type

Using the hasOwnProperty() Method

In JavaScript, the hasOwnProperty() function is used to determine whether the object has the supplied property as its own property. This is important for determining if the attribute was inherited by the object rather than being its own.

Checking an Object

let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};
  
// Check if key exists
let hasKey = user.hasOwnProperty('name'); 
  
if (hasKey) {
    console.log('This key exists.');
} else {
    console.log('This key does not exist.');
}

Checking an Array

You might begin to wonder if this would work for arrays. As we established earlier, an array is actually a prototype (instance) of the Object type, therefore it also has this method available to it.

let number = [12, 33, 14, 45];

// Check if key exists
number.hasOwnProperty(1); // Returns true
number.hasOwnProperty(0); // Returns true
number.hasOwnProperty(7); // Returns false because 7 is not an existing index on the array

Using the Object.key() Method

The static method Object.key generates and returns an array whose components are strings of the names (keys) of an object's properties. This may be used to loop through the object's keys, which we can then use to verify if any match a certain key in the object.

Using the some() Method

some() is a JavaScript method that tests a callback function on all the elements of the calling array and returns true if the callback function returns true for any of them.

Using some() for Objects

let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};
  
// Check if key exists
Object.keys(user).some(key => key === 'name'); // Returns true
Object.keys(user).some(key => key === 'role'); // Returns false

We could also customize this into a reusable function:

const checkKey = (obj, keyName) => {
    let keyExist = Object.keys(obj).some(key => key === keyName);
    console.log(keyExist);
};
  
checkKey(user, 'name'); // Return true

Using some() for an Array

let number = [12, 33, 14, 45];
    
// Check if key exists
number.some(value => value === 1); // Returns true
number.some(value => value === 7); // Returns false

Again, just like with the object, we could also make use of a similar customized reusable function to check a value's existence in an array:

const checkVal = (arr, val) => {
    let valExist = arr.some(value => value === val);
    console.log(valExist);
};

checkVal(number, 7); // Returns false
checkVal(number, 0); // Returns true

Using the indexOf() Method

JavaScript's indexOf() method will return the index of the first instance of an element in the array. If the element does not exist then, -1 is returned.

Using indexOf() for an Object

The Object type in JavaScript does not actually support the indexOf method, since its properties/keys do not inherently have indexed positions in the object. Instead, we can get the object's keys as an array and then check the existence of a key using the indexOf method:

let user = {
    name: 'John Doe',
    age: 17,
    profession: 'Farmer'
};

// Check if key exists
Object.keys(user).indexOf('name') // Returns 0
Object.keys(user).indexOf('role') // Returns -1

Keep in mind that JavaScript objects do not always preserve key order, so the index returned may not be as meaningful as in arrays. In this case, the index should primarily be used to determine just the existence of a key.

Here is an example of using this in a utility function:

const checkKey = (obj, keyName) => {
    if (Object.keys(obj).indexOf(keyName) !== -1) {
        console.log('This key exists');
    } else {
        console.log('This key does not exist');
    }
};
  
checkKey(user, 'name'); // Logs 'This key exists'
checkKey(user, 'role'); // Logs 'This key does not exists'

Using indexOf() for an Array

As we saw in the previous example, arrays do support the indexOf method, unlike objects. To use it, pass the value of the item you're looking for to indexOf, which will then return the position of that value if it exists in the array:

let number = [12, 33, 14, 45];
    
// Find position of the item in the array
number.indexOf(14); // Returns 2
number.indexOf(7);  // Returns -1

Conclusion

In this article, we have seen all of the possible ways in which we could check if a key or item exists in a JavaScript object/array. We show how to make use of the in operator, hasOwnProperty() method, and some method. We also saw how JS objects and arrays in similar in that arrays inherit from objects, and thus contain many of the same methods.

Original article source at:  https://stackabuse.com/

#javascript #object #array 

Фильтровать объект по ключу в JavaScript

Введение

Объекты JavaScript не являются итерируемыми , как массивы или строки, поэтому мы не можем использовать метод filter()непосредственно в файле Object. filter()позволяет нам перебирать массив и возвращает в новый массив только те элементы этого массива, которые соответствуют определенным критериям.

Если вы хотите узнать больше о методе filter() — прочтите наше Руководство по JavaScript-методу filter() !

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

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

Ключи извлекаются с помощью Object.keys(), а значения извлекаются с помощью Object.values(). Чтобы получить как ключи, так и значения, вы также можете использовать Object.entries(). В этой статье нас интересуют исключительно ключи для фильтрации ключей по определенным критериям.

Использование Object.keys() для фильтрации объекта

Метод Object.keys()используется для генерации массива, элементами которого являются строки, содержащие имена (ключи) свойств объекта. Объект передается в качестве аргумента Object.keys():

Object.keys(objectName);

Например, предположим, что у нас есть объект оценок пользователей по различным предметам:

const userScores = {
    chemistry: 60,
    mathematics: 70,
    physics: 80,
    english: 98
};

Мы можем пройтись по объекту и получить ключи, которые в этом примере будут субъектами:

const names = Object.keys(userScores);
console.log(names); // ["chemistry","mathematics","physics","english"]

После того, как вы сгенерировали ключи, вы можете использовать их filter()для циклического перебора существующих значений и возврата только тех, которые соответствуют указанным критериям. Наконец, вы можете использовать reduce(), например, для сбора отфильтрованных ключей и их значений в новый объект.

Примечание: filter() отлично сочетается с другими функциональными методами!

Предположим, у нас есть объект, и мы хотим вернуть только пары ключ-значение со словом «имя» в ключах:

const user = {
    firstName: "John",
    lastName: "Doe",
    userName: "johndoe12",
    email: "johndoe@stackabuse.com",
    age: 37,
    hobby: "Singing"
};

Мы могли бы фильтровать, используя ключ Objects:

const names = Object.keys(user)
    .filter((key) => key.includes("Name"))
    .reduce((obj, key) => {
        return Object.assign(obj, {
          [key]: user[key]
        });
  }, {});

console.log(names);

Мы использовали Object.keys(user)для генерации всех ключей в виде массива, в результате чего получился массив:

["firstName","lastName","userName","email","age","hobby"]

Затем мы использовали функцию массива includes()в качестве критерия внутри filter()метода, чтобы просмотреть каждый элемент в массиве, чтобы определить, содержит ли какой-либо ключ слово «Имя»:

["firstName","lastName","userName"]

Затем мы использовали reduce()для уменьшения массива до объекта.

Примечание. Функция reduce()принимает два аргумента: объект в качестве первого параметра (идентификатор) и значение текущей итерации в качестве второго.

Мы используем Object.assign()для объединения исходных объектов в целевой объект в создаваемом новом объекте. Функция Object.assign()берет то Object, что создается, и добавляет текущую пару ключ-значение, которую мы передаем в нее.

И в конце этого — у нас есть новый объект, отфильтрованный по ключам:

{ firstName: 'John', lastName: 'Doe', userName: 'johndoe12' }

Фильтровать массив объектов по ключу

Часто объекты, которые мы обрабатываем, упорядочены в виде массива. Фильтровать каждый так же просто, как фильтровать один — мы просто перебираем массив и применяем те же шаги:

const users = {
    John: { username: 'johncam112', age:19 },
    Daniel: { key: 'Dandandel1', age:21 },
    Ruth: { key: 'rutie01', age:24 },
    Joe: { key: 'Joemathuel', age:28 }
};

const selectedUsers = ['Ruth', 'Daniel'];

const filteredUsers = Object.keys(users)
    .filter(key => selectedUsers.includes(key))
    .reduce((obj, key) => {
        obj[key] = users[key];
        return obj;
  }, {});

console.log(filteredUsers);

В приведенном выше примере мы отфильтровали объект Users, чтобы возвращались только объекты из selectedUsers, отфильтровав их по ключу:

{
    Daniel: {
        key:"Dandandel1",
        age:21
},
    Ruth: {
        key:"rutie01",
        age:24
    }
}

Заключение

В этой небольшой статье мы рассмотрели фильтрацию объектов по значению с помощью метода Object.keys(), фильтрацию с помощью filter()метода.

Оригинальный источник статьи по адресу:   https://stackabuse.com/

#javascript #key #object 

在 JavaScript 中按键过滤对象

介绍

JavaScript 的对象不像数组或字符串那样可迭代，所以我们不能直接filter()在Object. filter()允许我们遍历一个数组并只返回该数组中符合特定条件的项目到一个新数组中。

如果您想阅读有关 filter() 方法的更多信息 - 请阅读我们的JavaScript 的 filter() 方法指南！

在本文中，我们将探讨如何在 JavaScript 中使用其键来过滤对象。

对象本质上是属性及其值的映射。这个键值对集合就是一个对象。我们可以自然地单独提取键和值：

使用 提取键Object.keys()，使用 提取值Object.values()。要检索键和值，您也可以使用Object.entries(). 我们只关心本文中的键，用于根据特定条件过滤键。

使用Object.keys()过滤对象

该Object.keys()方法用于生成一个数组，其元素是包含对象属性名称（键）的字符串。该对象作为参数传递给Object.keys()：

Object.keys(objectName);

例如，假设我们有一个用户在各个科目中得分的对象：

const userScores = {
    chemistry: 60,
    mathematics: 70,
    physics: 80,
    english: 98
};

我们可以遍历对象并获取键，对于这个例子来说就是主题：

const names = Object.keys(userScores);
console.log(names); // ["chemistry","mathematics","physics","english"]

生成键后，您可以使用filter()循环遍历现有值并仅返回满足指定条件的值。最后，您可以使用reduce()将过滤后的键及其值收集到一个新对象中，例如。

注意： filter()非常擅长与其他功能方法链接！

假设我们有一个对象，我们只想返回键中包含单词“name”的键值对：

const user = {
    firstName: "John",
    lastName: "Doe",
    userName: "johndoe12",
    email: "johndoe@stackabuse.com",
    age: 37,
    hobby: "Singing"
};

我们可以使用 Objects 键进行过滤：

const names = Object.keys(user)
    .filter((key) => key.includes("Name"))
    .reduce((obj, key) => {
        return Object.assign(obj, {
          [key]: user[key]
        });
  }, {});

console.log(names);

我们利用Object.keys(user)将所有键生成一个数组，得到一个数组：

["firstName","lastName","userName","email","age","hobby"]

然后，我们在方法中使用数组函数includes()作为条件，filter()遍历数组中的每个元素，以确定是否有任何键包含单词“Name”：

["firstName","lastName","userName"]

然后，我们利用reduce()将数组缩减为一个对象。

注意：该reduce()函数接受两个参数：一个对象作为第一个参数（身份），当前迭代值作为第二个。

我们正在使用Object.assign()将源对象组合成正在生成的新对象中的目标对象。该Object.assign()函数获取Object正在构建的对象，并添加我们传递给它的当前键值对。

最后 - 我们有一个新对象，通过键过滤：

{ firstName: 'John', lastName: 'Doe', userName: 'johndoe12' }

按键过滤对象数组

通常，我们正在处理的对象在一个数组中排序。过滤每一个就像过滤一个一样简单 - 我们只需遍历数组并应用相同的步骤：

const users = {
    John: { username: 'johncam112', age:19 },
    Daniel: { key: 'Dandandel1', age:21 },
    Ruth: { key: 'rutie01', age:24 },
    Joe: { key: 'Joemathuel', age:28 }
};

const selectedUsers = ['Ruth', 'Daniel'];

const filteredUsers = Object.keys(users)
    .filter(key => selectedUsers.includes(key))
    .reduce((obj, key) => {
        obj[key] = users[key];
        return obj;
  }, {});

console.log(filteredUsers);

在上面的示例中，我们过滤了 Users 对象以仅返回 的对象selectedUsers，通过键过滤它们：

{
    Daniel: {
        key:"Dandandel1",
        age:21
},
    Ruth: {
        key:"rutie01",
        age:24
    }
}

结论

在这篇简短的文章中——我们了解了按值过滤对象，使用方法Object.keys()，通过方法过滤filter()。

原始文章来源：https:   //stackabuse.com/

#javascript #key #object 

Filter an Object by Key in JavaScript

Introduction

JavaScript's Objects are not iterable like arrays or strings, so we can't make use of the filter() method directly on an Object. filter() allows us to iterate through an array and returns only the items of that array that fit certain criteria, into a new array.

If you'd like to read more about the filter() method - read our Guide to JavaScript's filter() Method!

In this article, we will explore how to filter an Object making use of its key in JavaScript.

An object is, essentially, a map of properties and their values. This key-value pair set is what an object is. We can naturally extract the keys and values individually:

Keys are extracted using Object.keys(), while values are extracted using Object.values(). To retrieve both keys and values, you may alternatively use Object.entries(). We are solely concerned with the keys in this article, for filtering keys against certain criteria.

Using Object.keys() to filter an Object

The Object.keys() method is used to generate an array whose elements are strings containing the names (keys) of an object's properties. The object is passed as an argument to Object.keys():

Object.keys(objectName);

For example, suppose we have an object of user scores in various subjects:

const userScores = {
    chemistry: 60,
    mathematics: 70,
    physics: 80,
    english: 98
};

We can loop through the object and fetch the keys, which for this example would be the subjects:

const names = Object.keys(userScores);
console.log(names); // ["chemistry","mathematics","physics","english"]

After you've generated the keys, you may use filter() to loop over the existing values and return just those that meet the specified criteria. Finally, you can use reduce() to collect the filtered keys and their values into a new object, for instance.

Note: filter() is great at chaining with other functional methods!

Assume we have an Object, and we want to return only key-value pairs with the word "name" in the keys:

const user = {
    firstName: "John",
    lastName: "Doe",
    userName: "johndoe12",
    email: "johndoe@stackabuse.com",
    age: 37,
    hobby: "Singing"
};

We could filter by making use of the Objects key:

const names = Object.keys(user)
    .filter((key) => key.includes("Name"))
    .reduce((obj, key) => {
        return Object.assign(obj, {
          [key]: user[key]
        });
  }, {});

console.log(names);

We made use of Object.keys(user) to generate all the keys as an array, resulting in an array:

["firstName","lastName","userName","email","age","hobby"]

We then used the array function includes() as the criteria, within the filter() method, to go over each element in the array to determine whether any key included the word "Name":

["firstName","lastName","userName"]

Then, we made use of reduce() to reduce the array down into an object.

Note: The reduce() function accepts two arguments: an object as the first parameter (identity) and the current iteration value as the second.

We are using Object.assign() to combine source objects into a target object in the new object being generated. The Object.assign() function takes the Object that is being built and adds the current key-value pair that we are passing into it.

And at the end of this - we have a new object, filtered by the keys:

{ firstName: 'John', lastName: 'Doe', userName: 'johndoe12' }

Filter Array of Objects by Key

Oftentimes, the objects we're processing are sequenced in an array. Filtering each is as easy as filtering one - we just iterate through the array and apply the same steps:

const users = {
    John: { username: 'johncam112', age:19 },
    Daniel: { key: 'Dandandel1', age:21 },
    Ruth: { key: 'rutie01', age:24 },
    Joe: { key: 'Joemathuel', age:28 }
};

const selectedUsers = ['Ruth', 'Daniel'];

const filteredUsers = Object.keys(users)
    .filter(key => selectedUsers.includes(key))
    .reduce((obj, key) => {
        obj[key] = users[key];
        return obj;
  }, {});

console.log(filteredUsers);

In the above example, we filtered the Users object to only return objects of the selectedUsers, filtering them by the key:

{
    Daniel: {
        key:"Dandandel1",
        age:21
},
    Ruth: {
        key:"rutie01",
        age:24
    }
}

Conclusion

In this short article - we've taken a look at filtering objects by value, using the Object.keys() method, filtered via the filter() method.

Original article source at:  https://stackabuse.com/

#javascript #key #object 

Fix TypeError: невозможно распаковать неитерируемый объект NoneType

При работе с последовательностями Python, такими как список или кортеж, вы можете получить следующую ошибку:

TypeError: cannot unpack non-iterable NoneType object

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

Существует два распространенных сценария возникновения этой ошибки:

1. Вы непреднамеренно распаковываете объект None
2. Забыть оператор return в вашей функции

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

1. Вы непреднамеренно распаковываете объект None

В Python вы можете установить элементы в последовательности для нескольких переменных в зависимости от позиции индекса этих элементов:

fruits = ["Grape", "Apple", "Mango"]

fruit_1, fruit_2, fruit_3  = fruits

print(fruit_1)  # Grape
print(fruit_2)  # Apple
print(fruit_3)  # Mango

Как видите, каждая переменная получает значение, определенное в fruitsсписке.

Ошибка возникает, когда вы присваиваете переменным значение Noneследующим образом:

fruit_1, fruit_2, fruit_3  = None

Выход:

Traceback (most recent call last):
  File "main.py", line 1, in <module>
    fruit_1, fruit_2, fruit_3  = None
TypeError: cannot unpack non-iterable NoneType object

Чтобы устранить эту ошибку, вам нужно убедиться, что вы не распаковываете объект None.

Вы можете сделать это, используя ifоператор, чтобы проверить, что переменная, которую вы хотите распаковать, не является None:

fruits = ["Grape", "Apple", "Mango"]

if fruits is not None:
    fruit_1, fruit_2, fruit_3  = fruits
else:
    print("The variable is None")

Используя ifоператор, как показано выше, Python распаковывает переменную, только fruitsесли она не является Noneобъектом.

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

Например, вы распаковываете переменную, которой присваивается возвращаемое значение метода, sort()следующим образом:

fruits = ["Grape", "Apple", "Mango"]

fruits = fruits.sort()

fruit_1, fruit_2, fruit_3  = fruits  # ❌

Ошибка возникает из-за того, что sort()метод изменяет исходный список, ничего не возвращая. Когда вы присваиваете возврат sort()переменной, этой переменной присваивается значение None.

Чтобы устранить ошибку, вам нужно вызвать sort()без присвоения возвращаемого значения переменной следующим образом:

fruits = ["Grape", "Apple", "Mango"]

fruits.sort()

fruit_1, fruit_2, fruit_3  = fruits  # ✅

print(fruit_1)  # Apple
print(fruit_2)  # Grape
print(fruit_3)  # Mango

Обратите внимание, что на этот раз мы не получаем никаких сообщений об ошибках, потому что распаковка работает должным образом.

2. Забыть оператор return в вашей функции

Предположим, у вас есть функция, которая возвращает список следующим образом:

def get_list():
    my_list = [1, 2, 3]

Затем вы пытаетесь распаковать объект, возвращенный при вызове функции, как показано ниже:

a, b, c = get_list()

Поскольку в вашей функции нет returnоператора, вы получите эту ошибку:

Traceback (most recent call last):
  File "main.py", line 4, in <module>
    a, b, c = get_list()
TypeError: cannot unpack non-iterable NoneType object

Функция Python возвращает значение Noneпо умолчанию, если в ней нет returnоператора, и поэтому возникает эта ошибка.

Чтобы исправить эту ошибку, вам нужно определить returnоператор в функции следующим образом:

def get_list():
    my_list = [1, 2, 3]
    return my_list

a, b, c = get_list()

print(a, b, c)  # 1 2 3

Теперь ошибка устранена, и мы можем нормально запустить код.

Я надеюсь, что это руководство поможет. До встречи в других статьях! 👋

Оригинальный источник статьи: https://sebhastian.com/

#python #object 

修复类型错误：无法解压不可迭代的 NoneType 对象

使用列表或元组等 Python 序列时，您可能会遇到以下错误：

TypeError: cannot unpack non-iterable NoneType object

当您使用解包语法将值对象分配None给一组变量时，通常会发生此错误。

发生此错误时有两种常见情况：

1. 您无意中解压了一个 None 对象
2. 忘记函数中的 return 语句

以下教程显示了导致此错误的示例以及如何修复它。

1. 你无意中解包了一个 None 对象

在 Python 中，您可以根据这些项目的索引位置将序列中的项目设置为多个变量：

fruits = ["Grape", "Apple", "Mango"]

fruit_1, fruit_2, fruit_3  = fruits

print(fruit_1)  # Grape
print(fruit_2)  # Apple
print(fruit_3)  # Mango

如您所见，每个变量都获得列表中定义的值fruits。

当您将变量分配给一个值时会发生错误，None如下所示：

fruit_1, fruit_2, fruit_3  = None

输出：

Traceback (most recent call last):
  File "main.py", line 1, in <module>
    fruit_1, fruit_2, fruit_3  = None
TypeError: cannot unpack non-iterable NoneType object

要解决此错误，您需要确保您没有解包None对象。

您可以通过使用if语句来检查要解压缩的变量是否不是None：

fruits = ["Grape", "Apple", "Mango"]

if fruits is not None:
    fruit_1, fruit_2, fruit_3  = fruits
else:
    print("The variable is None")

通过使用if如上所示的语句，Python 仅在变量fruits不是对象时才将其解包None。

有时，当您无意中解包一个有值的变量时，您也会遇到此错误None。

例如，您解压分配给方法返回值的变量，sort()如下所示：

fruits = ["Grape", "Apple", "Mango"]

fruits = fruits.sort()

fruit_1, fruit_2, fruit_3  = fruits  # ❌

发生错误是因为该sort()方法修改了原始列表而没有返回任何内容。当您将返回分配sort()给变量时，该变量会被分配一个None值。

要解决该错误，您需要调用sort()而不将返回值分配给变量，如下所示：

fruits = ["Grape", "Apple", "Mango"]

fruits.sort()

fruit_1, fruit_2, fruit_3  = fruits  # ✅

print(fruit_1)  # Apple
print(fruit_2)  # Grape
print(fruit_3)  # Mango

请注意，这次我们没有收到任何错误消息，因为解压缩按预期进行。

2. 忘记函数中的 return 语句

假设您有一个返回列表的函数，如下所示：

def get_list():
    my_list = [1, 2, 3]

然后，您尝试解压缩调用函数时返回的对象，如下所示：

a, b, c = get_list()

return因为你的函数中没有语句，你会得到这个错误：

Traceback (most recent call last):
  File "main.py", line 4, in <module>
    a, b, c = get_list()
TypeError: cannot unpack non-iterable NoneType object

Python函数None在没有return语句的情况下默认返回，所以才会出现这个错误。

要修复此错误，您需要return在函数中定义一条语句，如下所示：

def get_list():
    my_list = [1, 2, 3]
    return my_list

a, b, c = get_list()

print(a, b, c)  # 1 2 3

现在错误已经解决，我们可以正常运行代码了。

我希望本教程有所帮助。其他文章见！👋

原始文章来源：https: //sebhastian.com/

#python #object 

Fix TypeError: Cannot Unpack Non-iterable NoneType Object

While working with Python sequences such as a List or a Tuple, you might get the following error:

TypeError: cannot unpack non-iterable NoneType object

This error usually occurs when you assign an object of None value to a set of variables using the unpacking syntax.

There are two common scenarios when this error occurs:

1. You unintentionally unpack a None object
2. Forgetting the return statement in your function

The following tutorial shows an example that causes this error and how to fix it.

1. You unintentionally unpack a None object

In Python, you can set the items in a sequence to multiple variables based on the index position of those items:

fruits = ["Grape", "Apple", "Mango"]

fruit_1, fruit_2, fruit_3  = fruits

print(fruit_1)  # Grape
print(fruit_2)  # Apple
print(fruit_3)  # Mango

As you can see, each variable gets the value defined in the fruits list.

The error occurs when you assign the variables to a None value as follows:

fruit_1, fruit_2, fruit_3  = None

Output:

Traceback (most recent call last):
  File "main.py", line 1, in <module>
    fruit_1, fruit_2, fruit_3  = None
TypeError: cannot unpack non-iterable NoneType object

To resolve this error, you need to make sure that you’re not unpacking a None object.

You can do this by using an if statement to check that the variable you want to unpack is not None:

fruits = ["Grape", "Apple", "Mango"]

if fruits is not None:
    fruit_1, fruit_2, fruit_3  = fruits
else:
    print("The variable is None")

By using an if statement as shown above, Python only unpacks the variable fruits when it’s not a None object.

Sometimes, you also get this error when you unintentionally unpack a variable that has a None value.

For example, you unpack the variable that gets assigned the return value of the sort() method like this:

fruits = ["Grape", "Apple", "Mango"]

fruits = fruits.sort()

fruit_1, fruit_2, fruit_3  = fruits  # ❌

The error occurs because the sort() method modifies the original list without returning anything. When you assign the return of sort() to a variable, that variable gets assigned a None value.

To resolve the error, you need to call sort() without assigning the return value to a variable as follows:

fruits = ["Grape", "Apple", "Mango"]

fruits.sort()

fruit_1, fruit_2, fruit_3  = fruits  # ✅

print(fruit_1)  # Apple
print(fruit_2)  # Grape
print(fruit_3)  # Mango

Note that this time We don’t receive any error message because the unpack works as expected.

2. Forgetting the return statement in your function

Suppose you have a function that returns a list as follows:

def get_list():
    my_list = [1, 2, 3]

Then, you try to unpack the object returned when you call the function as shown below:

a, b, c = get_list()

Because you don’t have a return statement in your function, you’ll get this error:

Traceback (most recent call last):
  File "main.py", line 4, in <module>
    a, b, c = get_list()
TypeError: cannot unpack non-iterable NoneType object

A Python function returns None by default when it has no return statement, and that’s why this error occurs.

To fix this error, you need to define a return statement in the function as follows:

def get_list():
    my_list = [1, 2, 3]
    return my_list

a, b, c = get_list()

print(a, b, c)  # 1 2 3

The error is now resolved and we can run the code just fine.

I hope this tutorial helps. See you in other articles! 👋

Original article source at: https://sebhastian.com/

#python #object