10 tips for beginners of JavaScript

Although JavaScript has many programming methods, only 10 skills are selected here. These skills are a good starting point for beginners to understand JavaScript. In the previous programming language rankings, we have introduced the JavaScript language that is just getting started. As stated in the article, JavaScript is not only the most dynamic scripting language, or one of the most useful programming languages. Because most browsers are compatible with it, you can use it in these browsers. JavaScript is accepted quite quickly because it is so simple and widely used. Many programmers used to think of JavaScript as a "Toy language". However, AJAX entered the market and showed the opposite side. It showed completely different capabilities and functions for JavaScript.
As a result of this invention, programmers can now create Web applications with the effects of desktop applications, which is very helpful because data can be changed faster. These are some mini tips that help beginners better use JavaScript. JavaScript is widely used and has so many styles, so it can have a lot of skills. In addition, although it has many programming methods, I have only selected 10 skills. I think these skills are a good starting point for beginners to understand JavaScript.
1. Add an element at the end of an array.
This technique allows you to use the Length attribute to add an element at the end of an array, because the Length attribute is 1 more than the subscript of the last element of the array. This method is the same as the "push" method. For example:

var myArray = []; myArray[myArray.length] = 'New Element';

2. Adjust the length of an array.
The Length attribute is not read-only, so you can set the value of the Length attribute. In addition, you can use it to increase or decrease the length of the array. For example:

var myArray = [1,2,3]; myArray.length // 3 myArray.length = 2; //Delete the last element myArray.length = 20 // add 18 elements to the array; the elements have the undefined value.

3. Use "!" Convert any data type to Boolean
This technology allows you to use "!" Converts any data type (such as string, number, or integer) to Boolean. For example:

var myString = '23255'; typeof myString; //String myString = !!myString; typeof myString //Boolean

4. Convert Number to String
This technique allows you to add an empty string at the end of a number to convert the number to a string. For example:

var mynumber = 234; typeof mynumber; //Number mynumber += ''; typeof mynumber; //String

5. Learn how many variables a function requires.
This is a great technique that lets you know exactly how many variables a function requires. For example:

function add_nums(num1, num2){ return num1 + num2; } add_nums.length // 2 is the amount of parameters expected by the function add_nums

6. Use the "arguments" object to know how many parameters a function receives.
This technique allows you to use the "arguments" object to understand how many parameters a function receives. For example:

function add_nums(){ return arguments.length; } add_nums(23,11,32,56,89,89,89,44,6); //this return the number 9

This technique is useful when you need to check the validity of the number of parameters, or when you need to create a function that is not sure about the number of parameters.

Function sum_three_nums () {if (arguments. length! = 3) throw new Error ('received' + arguments. length + 'parameters and shocould work with 3');} sum_three_nums (); // Return the error message function sum_num () {var total = 0; for (var I = 0; I
7. Use objects as parameters to organize and improve functions.
In modern Web development, one of the most common purposes of objects is to treat them as function parameters. It is always difficult to remember this rule of function parameters. However, it is very helpful to use an object because we don't have to worry about the parameter rules anymore. Moreover, it is more organized and allows users to better understand what we are going to do. This method allows you to use objects as parameters to organize and improve functions. For example:
function insertData(name,lastName,phone,address){ code here; }
The code after reconstruction is as follows:
function insertData(parameters){ var name = parameters.name; var lastName = parameters.lastName; var phone = parameters.phone; var address = parameters.address; }
It is also useful when you want to use the default value. For example:
function insertData(parameters){ var name = parameters.name; var lastName = parameters.lastName; var phone = parameters.phone; var address = parameters.address; var status = parameters.status || 'single' //If status is not defined as a property //in the object the variable status take single as value }
To use this function, we can send data in two ways:
//Example 1 insertData({name:'Mike', lastName:'Rogers', phone:'555-555-5555',address:'the address', status:'married'}); //Example 2 var myData = { name:'Mike', lastName:'Rogers', phone:'555-555-5555', address:'the address', status:'married' }; insertData(myData);
8. functions are data.
Functions are data like strings or numbers. We can use them as function parameters to pass them, which can create amazing and "awesome" Web applications. This method is very useful, and almost all mainstream frameworks use this method. For example:
function byId(element, event, f){ Document.getElementById(element).['on'+event] = f; //f is the function that we pass as parameter } byId('myBtn','click',function(){alert('Hello World')}); Another example of functions as data: //Example 1 function msg(m){ Alert(m); } //Example 2 var msg = function(m){ alert(m);}
These functions are almost identical. The only difference is that they are used. For example, you can use the first function before you declare it. However, the second function can only be used after it is declared:
//Example 1 msg('Hello world'); //This will work function msg(m){ alert(m); } //Example 2 msg('Hello world'); //Does not work because JavaScript cannot find the function msg because is used before is been declared. var msg = function(m){ alert(m)}
9. expand local objects
Although some JavaScript leaders do not recommend this technology, it has been used by some frameworks. It allows you to create helper methods for JavaScript APIs.
// We create the method prototype for our arrays // It only sums numeric elements Array. prototype. sum = function () {var len = this. length; total = 0; for (var I = 0; I
  
   
10, Boolean
Pay attention to the differences between them, because it will save you time to debug the script.
   
'' == '0' // false 0 == '' // true 0 == '0' // true false == 'false' // false false == '0' // true false == undefined // false false == null // false null == undefined // true true == 1 // true '' == null // false false == '' // true
   
If you have read these scripts elsewhere, these skills can help you understand them. These skills are not even the tip of the iceberg for all JavaScript Functions, but this is the beginning! Do not hesitate to leave your comments, questions, extra skills or concerns. But remember, this is an article for beginners !! I hope to receive emails from developers! Enjoy!