safari es version

ES5 to ESNext — here’s every feature added to JavaScript since 2015

I wrote this article to help you move from pre-ES6 knowledge of JavaScript and get you quickly up to speed with the most recent advancements of the language.

JavaScript today is in the privileged position to be the only language that can run natively in the browser, and is highly integrated and optimized for that.

The future of JavaScript is going to be brilliant. Keeping up with the changes shouldn’t be harder than it already is, and my goal here is to give you a quick yet comprehensive overview of the new stuff available to us.

Click here to get a PDF / ePub / Mobi version of this post to read offline

Introduction to ECMAScript

Whenever you read about JavaScript you’ll inevitably see one of these terms: ES3, ES5, ES6, ES7, ES8, ES2015, ES2016, ES2017, ECMAScript 2017, ECMAScript 2016, ECMAScript 2015… what do they mean?

They are all referring to a standard , called ECMAScript.

ECMAScript is the standard upon which JavaScript is based , and it’s often abbreviated to ES .

Beside JavaScript, other languages implement(ed) ECMAScript, including:

• ActionScript (the Flash scripting language), which is losing popularity since Flash will be officially discontinued in 2020
• JScript (the Microsoft scripting dialect), since at the time JavaScript was supported only by Netscape and the browser wars were at their peak, Microsoft had to build its own version for Internet Explorer

but of course JavaScript is the most popular and widely used implementation of ES.

Why this weird name? Ecma International is a Swiss standards association who is in charge of defining international standards.

When JavaScript was created, it was presented by Netscape and Sun Microsystems to Ecma and they gave it the name ECMA-262 alias ECMAScript .

This press release by Netscape and Sun Microsystems (the maker of Java) might help figure out the name choice, which might include legal and branding issues by Microsoft which was in the committee, according to Wikipedia .

After IE9, Microsoft stopped branding its ES support in browsers as JScript and started calling it JavaScript (at least, I could not find references to it any more).

So as of 201x, the only popular language supporting the ECMAScript spec is JavaScript.

Current ECMAScript version

The current ECMAScript version is ES2018 .

It was released in June 2018.

What is TC39

TC39 is the committee that evolves JavaScript.

The members of TC39 are companies involved in JavaScript and browser vendors, including Mozilla, Google, Facebook, Apple, Microsoft, Intel, PayPal, SalesForce and others.

Every standard version proposal must go through various stages, which are explained here .

ES Versions

I found it puzzling why sometimes an ES version is referenced by edition number and sometimes by year, and I am confused by the year by chance being -1 on the number, which adds to the general confusion around JS/ES ?

Before ES2015, ECMAScript specifications were commonly called by their edition. So ES5 is the official name for the ECMAScript specification update published in 2009.

Why does this happen? During the process that led to ES2015, the name was changed from ES6 to ES2015, but since this was done late, people still referenced it as ES6, and the community has not left the edition naming behind — the world is still calling ES releases by edition number .

This table should clear things up a bit:

Let’s dive into the specific features added to JavaScript since ES5. Let’s start with the ES2015 features.

let and const

Until ES2015, var was the only construct available for defining variables.

If you forget to add var you will be assigning a value to an undeclared variable, and the results might vary.

In modern environments, with strict mode enabled, you will get an error. In older environments (or with strict mode disabled) this will initialize the variable and assign it to the global object.

If you don’t initialize the variable when you declare it, it will have the undefined value until you assign a value to it.

You can redeclare the variable many times, overriding it:

You can also declare multiple variables at once in the same statement:

The scope is the portion of code where the variable is visible.

A variable initialized with var outside of any function is assigned to the global object, has a global scope and is visible everywhere. A variable initialized with var inside a function is assigned to that function, it's local and is visible only inside it, just like a function parameter.

Any variable defined in a function with the same name as a global variable takes precedence over the global variable, shadowing it.

It’s important to understand that a block (identified by a pair of curly braces) does not define a new scope. A new scope is only created when a function is created, because var does not have block scope, but function scope.

Inside a function, any variable defined in it is visible throughout all the function code, even if the variable is declared at the end of the function it can still be referenced in the beginning, because JavaScript before executing the code actually moves all variables on top (something that is called hoisting ). To avoid confusion, always declare variables at the beginning of a function.

let is a new feature introduced in ES2015 and it's essentially a block scoped version of var . Its scope is limited to the block, statement or expression where it's defined, and all the contained inner blocks.

Modern JavaScript developers might choose to only use let and completely discard the use of var .

If let seems an obscure term, just read let color = 'red' as let the color be red and it all makes much more sense

Defining let outside of any function - contrary to var - does not create a global variable.

Using const

Variables declared with var or let can be changed later on in the program, and reassigned. Once a const is initialized, its value can never be changed again, and it can't be reassigned to a different value.

We can’t assign a different literal to the a const. We can however mutate a if it's an object that provides methods that mutate its contents.

const does not provide immutability, just makes sure that the reference can't be changed.

const has block scope, same as let .

Modern JavaScript developers might choose to always use const for variables that don't need to be reassigned later in the program, because we should always use the simplest construct available to avoid making errors down the road.

Arrow Functions

Arrow functions, since their introduction, changed forever how JavaScript code looks (and works).

In my opinion this change was so welcome that you now rarely see the usage of the function keyword in modern codebases. Although that has still its usage.

Visually, it’s a simple and welcome change, which allows you to write functions with a shorter syntax, from:

If the function body contains just a single statement, you can omit the brackets and write all on a single line:

Parameters are passed in the parentheses:

If you have one (and just one) parameter, you could omit the parentheses completely:

Thanks to this short syntax, arrow functions encourage the use of small functions .

Implicit return

Arrow functions allow you to have an implicit return: values are returned without having to use the return keyword.

It works when there is a one-line statement in the function body:

Another example, when returning an object, remember to wrap the curly brackets in parentheses to avoid it being considered the wrapping function body brackets:

How this works in arrow functions

this is a concept that can be complicated to grasp, as it varies a lot depending on the context and also varies depending on the mode of JavaScript ( strict mode or not).

It’s important to clarify this concept because arrow functions behave very differently compared to regular functions.

When defined as a method of an object, in a regular function this refers to the object, so you can do:

calling car.fullName() will return "Ford Fiesta" .

The this scope with arrow functions is inherited from the execution context. An arrow function does not bind this at all, so its value will be looked up in the call stack, so in this code car.fullName() will not work, and will return the string "undefined undefined" :

Due to this, arrow functions are not suited as object methods.

Arrow functions cannot be used as constructors either, when instantiating an object will raise a TypeError .

This is where regular functions should be used instead, when dynamic context is not needed .

This is also a problem when handling events. DOM Event listeners set this to be the target element, and if you rely on this in an event handler, a regular function is necessary:

JavaScript has quite an uncommon way to implement inheritance: prototypical inheritance. Prototypal inheritance , while in my opinion great, is unlike most other popular programming language’s implementation of inheritance, which is class-based.

People coming from Java or Python or other languages had a hard time understanding the intricacies of prototypal inheritance, so the ECMAScript committee decided to sprinkle syntactic sugar on top of prototypical inheritance so that it resembles how class-based inheritance works in other popular implementations.

This is important: JavaScript under the hood is still the same, and you can access an object prototype in the usual way.

A class definition

This is how a class looks.

A class has an identifier, which we can use to create new objects using new ClassIdentifier() .

When the object is initialized, the constructor method is called, with any parameters passed.

A class also has as many methods as it needs. In this case hello is a method and can be called on all objects derived from this class:

Class inheritance

A class can extend another class, and objects initialized using that class inherit all the methods of both classes.

If the inherited class has a method with the same name as one of the classes higher in the hierarchy, the closest method takes precedence:

(the above program prints “ Hello, I am Flavio. I am a programmer. ”)

Classes do not have explicit class variable declarations, but you must initialize any variable in the constructor.

Inside a class, you can reference the parent class calling super() .

Static methods

Normally methods are defined on the instance, not on the class.

Static methods are executed on the class instead:

Private methods

JavaScript does not have a built-in way to define private or protected methods.

There are workarounds, but I won’t describe them here.

Getters and setters

You can add methods prefixed with get or set to create a getter and setter, which are two different pieces of code that are executed based on what you are doing: accessing the variable, or modifying its value.

If you only have a getter, the property cannot be set, and any attempt at doing so will be ignored:

If you only have a setter, you can change the value but not access it from the outside:

Default parameters

This is a doSomething function which accepts param1 .

We can add a default value for param1 if the function is invoked without specifying a parameter:

This works for more parameters as well, of course:

What if you have an unique object with parameters values in it?

Once upon a time, if we had to pass an object of options to a function, in order to have default values of those options if one of them was not defined, you had to add a little bit of code inside the function:

With destructuring you can provide default values, which simplifies the code a lot:

If no object is passed when calling our colorize function, similarly we can assign an empty object by default:

Template Literals

Template Literals allow you to work with strings in a novel way compared to ES5 and below.

The syntax at a first glance is very simple, just use backticks instead of single or double quotes:

They are unique because they provide a lot of features that normal strings built with quotes do not, in particular:

• they offer a great syntax to define multiline strings
• they provide an easy way to interpolate variables and expressions in strings
• they allow you to create DSLs with template tags (DSL means domain specific language, and it’s for example used in React by Styled Components, to define CSS for a component)

Let’s dive into each of these in detail.

Multiline strings

Pre-ES6, to create a string spanning over two lines you had to use the \ character at the end of a line:

This allows to create a string on 2 lines, but it’s rendered on just one line:

first part second part

To render the string on multiple lines as well, you explicitly need to add \n at the end of each line, like this:

Template literals make multiline strings much simpler.

Once a template literal is opened with the backtick, you just press enter to create a new line, with no special characters, and it’s rendered as-is:

Keep in mind that space is meaningful, so doing this:

is going to create a string like this:

an easy way to fix this problem is by having an empty first line, and appending the trim() method right after the closing backtick, which will eliminate any space before the first character:

Interpolation

Template literals provide an easy way to interpolate variables and expressions into strings.

You do so by using the ${...} syntax:

inside the ${} you can add anything, even expressions:

Template tags

Tagged templates is one feature that might sound less useful at first for you, but it’s actually used by lots of popular libraries around, like Styled Components or Apollo, the GraphQL client/server lib, so it’s essential to understand how it works.

In Styled Components template tags are used to define CSS strings:

In Apollo template tags are used to define a GraphQL query schema:

The styled.button and gql template tags highlighted in those examples are just functions :

this function returns a string, which can be the result of any kind of computation.

literals is an array containing the template literal content tokenized by the expressions interpolations.

expressions contains all the interpolations.

If we take an example above:

literals is an array with two items. The first is something , the string until the first interpolation, and the second is an empty string, the space between the end of the first interpolation (we only have one) and the end of the string.

expressions in this case is an array with a single item, 6 .

A more complex example is:

in this case literals is an array where the first item is:

the second is:

and the third is:

expressions in this case is an array with two items, x and 6 .

The function that is passed those values can do anything with them, and this is the power of this kind feature.

The most simple example is replicating what the string interpolation does, by joining literals and expressions :

and this is how interpolate works:

Destructuring assignments

Given an object, you can extract just some values and put them into named variables:

name and age contain the desired values.

The syntax also works on arrays:

This statement creates 3 new variables by getting the items with index 0, 1, 4 from the array a :

Enhanced Object Literals

In ES2015 Object Literals gained superpowers.

Simpler syntax to include variables

Instead of doing

A prototype can be specified with

Dynamic properties

For-of loop.

ES5 back in 2009 introduced forEach() loops. While nice, they offered no way to break, like for loops always did.

ES2015 introduced the for-of loop , which combines the conciseness of forEach with the ability to break:

Notice the use of const . This loop creates a new scope in every iteration, so we can safely use that instead of let .

The difference with for...in is:

• for...of iterates over the property values
• for...in iterates the property names

A promise is commonly defined as a proxy for a value that will eventually become available .

Promises are one way to deal with asynchronous code, without writing too many callbacks in your code.

Async functions use the promises API as their building block, so understanding them is fundamental even if in newer code you’ll likely use async functions instead of promises.

How promises work, in brief

Once a promise has been called, it will start in pending state . This means that the caller function continues the execution, while it waits for the promise to do its own processing, and give the caller function some feedback.

At this point, the caller function waits for it to either return the promise in a resolved state , or in a rejected state , but as you know JavaScript is asynchronous, so the function continues its execution while the promise does it work .

Which JS API use promises?

In addition to your own code and library code, promises are used by standard modern Web APIs such as:

• the Battery API
• the Fetch API
• Service Workers

It’s unlikely that in modern JavaScript you’ll find yourself not using promises, so let’s start diving right into them.

Creating a promise

The Promise API exposes a Promise constructor, which you initialize using new Promise() :

As you can see the promise checks the done global constant, and if that's true, we return a resolved promise, otherwise a rejected promise.

Using resolve and reject we can communicate back a value, in the above case we just return a string, but it could be an object as well.

Consuming a promise

In the last section, we introduced how a promise is created.

Now let’s see how the promise can be consumed or used.

Running checkIfItsDone() will execute the isItDoneYet() promise and will wait for it to resolve, using the then callback, and if there is an error, it will handle it in the catch callback.

Chaining promises

A promise can be returned to another promise, creating a chain of promises.

A great example of chaining promises is given by the Fetch API , a layer on top of the XMLHttpRequest API, which we can use to get a resource and queue a chain of promises to execute when the resource is fetched.

The Fetch API is a promise-based mechanism, and calling fetch() is equivalent to defining our own promise using new Promise() .

Example of chaining promises

In this example, we call fetch() to get a list of TODO items from the todos.json file found in the domain root, and we create a chain of promises.

Running fetch() returns a response , which has many properties, and within those we reference:

• status , a numeric value representing the HTTP status code
• statusText , a status message, which is OK if the request succeeded

response also has a json() method, which returns a promise that will resolve with the content of the body processed and transformed into JSON.

So given those premises, this is what happens: the first promise in the chain is a function that we defined, called status() , that checks the response status and if it's not a success response (between 200 and 299), it rejects the promise.

This operation will cause the promise chain to skip all the chained promises listed and will skip directly to the catch() statement at the bottom, logging the Request failed text along with the error message.

If that succeeds instead, it calls the json() function we defined. Since the previous promise, when successful, returned the response object, we get it as an input to the second promise.

In this case, we return the data JSON processed, so the third promise receives the JSON directly:

and we log it to the console.

Handling errors

In the above example, in the previous section, we had a catch that was appended to the chain of promises.

When anything in the chain of promises fails and raises an error or rejects the promise, the control goes to the nearest catch() statement down the chain.

Cascading errors

If inside the catch() you raise an error, you can append a second catch() to handle it, and so on.

Orchestrating promises

Promise.all().

If you need to synchronize different promises, Promise.all() helps you define a list of promises, and execute something when they are all resolved.

The ES2015 destructuring assignment syntax allows you to also do

You are not limited to using fetch of course, any promise is good to go .

Promise.race()

Promise.race() runs as soon as one of the promises you pass to it resolves, and it runs the attached callback just once with the result of the first promise resolved.

ES Modules is the ECMAScript standard for working with modules.

While Node.js has been using the CommonJS standard for years, the browser never had a module system, as every major decision such as a module system must be first standardized by ECMAScript and then implemented by the browser.

This standardization process completed with ES2015 and browsers started implementing this standard trying to keep everything well aligned, working all in the same way, and now ES Modules are supported in Chrome, Safari, Edge and Firefox (since version 60).

Modules are very cool, because they let you encapsulate all sorts of functionality, and expose this functionality to other JavaScript files, as libraries.

The ES Modules Syntax

The syntax to import a module is:

while CommonJS uses

A module is a JavaScript file that exports one or more values (objects, functions or variables), using the export keyword. For example, this module exports a function that returns a string uppercase:

uppercase.js

In this example, the module defines a single, default export , so it can be an anonymous function. Otherwise it would need a name to distinguish it from other exports.

Now, any other JavaScript module can import the functionality offered by uppercase.js by importing it.

An HTML page can add a module by using a <scri pt> tag with the sp ecial type="m odule" attribute:

Note: this module import behaves like a defer script load. See efficiently load JavaScript with defer and async

It’s important to note that any script loaded with type="module" is loaded in strict mode.

In this example, the uppercase.js module defines a default export , so when we import it, we can assign it a name we prefer:

and we can use it:

You can also use an absolute path for the module import, to reference modules defined on another domain:

This is also valid import syntax:

This is not:

It’s either absolute, or has a ./ or / before the name.

Other import/export options

We saw this example above:

This creates one default export. In a file however you can export more than one thing, by using this syntax:

Another module can import all those exports using

You can import just a few of those exports, using the destructuring assignment:

You can rename any import, for convenience, using as :

You can import the default export, and any non-default export by name, like in this common React import:

You can see an ES Modules example here: https://glitch.com/edit/#!/flavio-es-modules-example?path=index.html

Modules are fetched using CORS. This means that if you reference scripts from other domains, they must have a valid CORS header that allows cross-site loading (like Access-Control-Allow-Origin: * )

What about browsers that do not support modules?

Use a combination of type="module" and nomodule :

Wrapping up modules

ES Modules are one of the biggest features introduced in modern browsers. They are part of ES6 but the road to implement them has been long.

We can now use them! But we must also remember that having more than a few modules is going to have a performance hit on our pages, as it’s one more step that the browser must perform at runtime.

Webpack is probably going to still be a huge player even if ES Modules land in the browser, but having such a feature directly built in the language is huge for a unification of how modules work client-side and on Node.js as well.

New String methods

Any string value got some new instance methods:

codePointAt()

Repeats the strings for the specified number of times:

Returns an empty string if there is no parameter, or the parameter is 0 . If the parameter is negative you'll get a RangeError.

This method can be used to handle Unicode characters that cannot be represented by a single 16-bit Unicode unit, but need 2 instead.

Using charCodeAt() you need to retrieve the first, and the second, and combine them. Using codePointAt() you get the whole character in one call.

For example, this Chinese character “?” is composed by 2 UTF-16 (Unicode) parts:

If you create a new character by combining those unicode characters:

You can get the same result sign codePointAt() :

More on Unicode and working with it in my Unicode guide .

New Object methods

ES2015 introduced several static methods under the Object namespace:

• Object.is() determines if two values are the same value
• Object.assign() used to shallow copy an object
• Object.setPrototypeOf sets an object prototype

Object.is()

This methods aims to help comparing values.

The result is always false unless:

• a and b are the same exact object
• a and b are equal strings (strings are equal when composed by the same characters)
• a and b are equal numbers (numbers are equal when their value is equal)
• a and b are both undefined , both null , both NaN , both true or both false

0 and -0 are different values in JavaScript, so pay attention in this special case (convert all to +0 using the + unary operator before comparing, for example).

Object.assign()

Introduced in ES2015 , this method copies all the enumerable own properties of one or more objects into another.

Its primary use case is to create a shallow copy of an object.

Being a shallow copy, values are cloned, and objects references are copied (not the objects themselves), so if you edit an object property in the original object, that’s modified also in the copied object, since the referenced inner object is the same:

I mentioned “one or more”:

Object.setPrototypeOf()

Set the prototype of an object. Accepts two arguments: the object and the prototype.

The spread operator

You can expand an array, an object or a string using the spread operator ...

Let’s start with an array example. Given

you can create a new array using

You can also create a copy of an array using

This works for objects as well. Clone an object with:

Using strings, the spread operator creates an array with each char in the string:

This operator has some pretty useful applications. The most important one is the ability to use an array as function argument in a very simple way:

(In the past you could do this using f.apply(null, a) but that's not as nice and readable.)

The rest element is useful when working with array destructuring :

and spread elements :

ES2018 introduces rest properties, which are the same but for objects.

Rest properties :

Spread properties allow us to create a new object by combining the properties of the object passed after the spread operator:

A Set data structure allows us to add data to a container.

A Set is a collection of objects or primitive types (strings, numbers or booleans), and you can think of it as a Map where values are used as map keys, with the map value always being a boolean true.

Initialize a Set

A Set is initialized by calling:

Add items to a Set

You can add items to the Set by using the add method:

A set only stores unique elements, so calling s.add('one') multiple times won't add new items.

You can’t add multiple elements to a set at the same time. You need to call add() multiple times.

Check if an item is in the set

Once an element is in the set, we can check if the set contains it:

Delete an item from a Set by key

Use the delete() method:

Determine the number of items in a Set

Use the size property:

Delete all items from a Set

Use the clear() method:

Iterate the items in a Set

Use the keys() or values() methods - they are equivalent:

The entries() method returns an iterator, which you can use like this:

calling i.next() will return each element as a { value, done = false } object until the iterator ends, at which point done is true .

You can also use the forEach() method on the set:

or you can just use the set in a for..of loop:

Initialize a Set with values

You can initialize a Set with a set of values:

Convert the Set keys into an array

A WeakSet is a special kind of Set.

In a Set, items are never garbage collected. A WeakSet instead lets all its items be freely garbage collected. Every key of a WeakSet is an object. When the reference to this object is lost, the value can be garbage collected.

Here are the main differences:

• you cannot iterate over the WeakSet
• you cannot clear all items from a WeakSet
• you cannot check its size

A WeakSet is generally used by framework-level code, and only exposes these methods:

A Map data structure allows us to associate data to a key.

Before its introduction, people generally used objects as maps, by associating some object or value to a specific key value:

ES6 introduced the Map data structure, providing us a proper tool to handle this kind of data organization.

A Map is initialized by calling:

Add items to a Map

You can add items to the map by using the set method:

Get an item from a map by key

And you can get items out of a map by using get :

Delete an item from a map by key

Delete all items from a map, check if a map contains an item by key.

Use the has() method:

Find the number of items in a map

Initialize a map with values.

You can initialize a map with a set of values:

Just like any value (object, array, string, number) can be used as the value of the key-value entry of a map item, any value can be used as the key , even objects.

If you try to get a non-existing key using get() out of a map, it will return undefined .

Weird situations you’ll almost never find in real life

Iterate over map keys.

Map offers the keys() method we can use to iterate on all the keys:

Iterate over map values

The Map object offers the values() method we can use to iterate on all the values:

Iterate over map key, value pairs

The Map object offers the entries() method we can use to iterate on all the values:

which can be simplified to

Convert the map keys into an array

Convert the map values into an array.

A WeakMap is a special kind of map.

In a map object, items are never garbage collected. A WeakMap instead lets all its items be freely garbage collected. Every key of a WeakMap is an object. When the reference to this object is lost, the value can be garbage collected.

• you cannot iterate over the keys or values (or key-values) of a WeakMap
• you cannot clear all items from a WeakMap

A WeakMap exposes those methods, which are equivalent to the Map ones:

The use cases of a WeakMap are less evident than the ones of a Map, and you might never find the need for them, but essentially it can be used to build a memory-sensitive cache that is not going to interfere with garbage collection, or for careful encapsulation and information hiding.

Generators are a special kind of function with the ability to pause itself, and resume later, allowing other code to run in the meantime.

See the full JavaScript Generators Guide for a detailed explanation of the topic.

The code decides that it has to wait, so it lets other code “in the queue” to run, and keeps the right to resume its operations “when the thing it’s waiting for” is done.

All this is done with a single, simple keyword: yield . When a generator contains that keyword, the execution is halted.

A generator can contain many yield keywords, thus halting itself multiple times, and it's identified by the *function keyword, which is not to be confused with the pointer dereference operator used in lower level programming languages such as C, C++ or Go.

Generators enable whole new paradigms of programming in JavaScript, allowing:

• 2-way communication while a generator is running
• long-lived while loops which do not freeze your program

Here is an example of a generator which explains how it all works.

We initialize it with

Then we start the iterator on our generator:

This first iteration starts the iterator. The code returns this object:

What happens is: the code runs the function, with input = 10 as it was passed in the generator constructor. It runs until it reaches the yield , and returns the content of yield : input / 2 = 5 . So we got a value of 5, and the indication that the iteration is not done (the function is just paused).

In the second iteration we pass the value 7 :

and what we got back is:

7 was placed as the value of doubleThat . Important: you might read like input / 2 was the argument, but that's just the return value of the first iteration. We now skip that, and use the new input value, 7 , and multiply it by 2.

We then reach the second yield, and that returns doubleThat , so the returned value is 14 .

In the next, and last, iteration, we pass in 100

and in return we got

As the iteration is done (no more yield keywords found) and we just return (input * doubleThat * another) which amounts to 10 * 14 * 100 .

Those were the features introduced in ES2015. Let’s now dive into ES2016 which is much smaller in scope.

Array.prototype.includes()

This feature introduces a more readable syntax for checking if an array contains an element.

With ES6 and lower, to check if an array contained an element you had to use indexOf , which checks the index in the array, and returns -1 if the element is not there.

Since -1 is evaluated as a true value, you could not do for example

With this feature introduced in ES7 we can do

Exponentiation Operator

The exponentiation operator ** is the equivalent of Math.pow() , but brought into the language instead of being a library function.

This feature is a nice addition for math intensive JS applications.

The ** operator is standardized across many languages including Python, Ruby, MATLAB, Lua, Perl and many others.

Those were the features introduced in 2016. Let’s now dive into 2017

String padding

The purpose of string padding is to add characters to a string , so it reaches a specific length .

ES2017 introduces two String methods: padStart() and padEnd() .

Sample usage:

Object.values()

This method returns an array containing all the object own property values.

Object.values() also works with arrays:

Object.entries()

This method returns an array containing all the object own properties, as an array of [key, value] pairs.

Object.entries() also works with arrays:

Object.getOwnPropertyDescriptors()

This method returns all own (non-inherited) properties descriptors of an object.

Any object in JavaScript has a set of properties, and each of these properties has a descriptor.

A descriptor is a set of attributes of a property, and it’s composed by a subset of the following:

• value : the value of the property
• writable : true the property can be changed
• get : a getter function for the property, called when the property is read
• set : a setter function for the property, called when the property is set to a value
• configurable : if false, the property cannot be removed nor any attribute can be changed, except its value
• enumerable : true if the property is enumerable

Object.getOwnPropertyDescriptors(obj) accepts an object, and returns an object with the set of descriptors.

In what way is this useful?

ES6 gave us Object.assign() , which copies all enumerable own properties from one or more objects, and return a new object.

However there is a problem with that, because it does not correctly copies properties with non-default attributes.

If an object for example has just a setter, it’s not correctly copied to a new object, using Object.assign() .

For example with

This won’t work:

But this will work:

As you can see with a simple console test:

person2 misses the setter, it was not copied over.

The same limitation goes for shallow cloning objects with Object.create() .

Trailing commas

This feature allows to have trailing commas in function declarations, and in functions calls:

This change will encourage developers to stop the ugly “comma at the start of the line” habit.

Async functions

JavaScript evolved in a very short time from callbacks to promises (ES2015), and since ES2017 asynchronous JavaScript is even simpler with the async/await syntax.

Async functions are a combination of promises and generators, and basically, they are a higher level abstraction over promises. Let me repeat: async/await is built on promises .

Why were async/await introduced?

They reduce the boilerplate around promises, and the “don’t break the chain” limitation of chaining promises.

When Promises were introduced in ES2015, they were meant to solve a problem with asynchronous code, and they did, but over the 2 years that separated ES2015 and ES2017, it was clear that promises could not be the final solution .

Promises were introduced to solve the famous callback hell problem, but they introduced complexity on their own, and syntax complexity.

They were good primitives around which a better syntax could be exposed to developers, so when the time was right we got async functions .

They make the code look like it’s synchronous, but it’s asynchronous and non-blocking behind the scenes.

How it works

An async function returns a promise, like in this example:

When you want to call this function you prepend await , and the calling code will stop until the promise is resolved or rejected . One caveat: the client function must be defined as async . Here's an example:

A quick example

This is a simple example of async/await used to run a function asynchronously:

The above code will print the following to the browser console:

Promise all the things

Prepending the async keyword to any function means that the function will return a promise.

Even if it’s not doing so explicitly, it will internally make it return a promise.

This is why this code is valid:

and it’s the same as:

The code is much simpler to read

As you can see in the example above, our code looks very simple. Compare it to code using plain promises, with chaining and callback functions.

And this is a very simple example, the major benefits will arise when the code is much more complex.

For example here’s how you would get a JSON resource, and parse it, using promises:

And here is the same functionality provided using await/async:

Multiple async functions in series

Async functions can be chained very easily, and the syntax is much more readable than with plain promises:

Will print:

Easier debugging

Debugging promises is hard because the debugger will not step over asynchronous code.

Async/await makes this very easy because to the compiler it’s just like synchronous code.

Shared Memory and Atomics

WebWorkers are used to create multithreaded programs in the browser.

They offer a messaging protocol via events. Since ES2017, you can create a shared memory array between web workers and their creator, using a SharedArrayBuffer .

Since it’s unknown how much time writing to a shared memory portion takes to propagate, Atomics are a way to enforce that when reading a value, any kind of writing operation is completed.

Any more detail on this can be found in the spec proposal , which has since been implemented.

This was ES2017. Let me now introduce the ES2018 features

Rest/Spread Properties

ES2015 introduced the concept of a rest element when working with array destructuring :

ES2018 introduces the same but for objects.

Spread properties allow to create a new object by combining the properties of the object passed after the spread operator:

Asynchronous iteration

The new construct for-await-of allows you to use an async iterable object as the loop iteration:

Since this uses await , you can use it only inside async functions, like a normal await .

Promise.prototype.finally()

When a promise is fulfilled, successfully it calls the then() methods, one after another.

If something fails during this, the then() methods are jumped and the catch() method is executed.

finally() allow you to run some code regardless of the successful or not successful execution of the promise:

Regular Expression improvements

ES2018 introduced a number of improvements regarding Regular Expressions. I recommend my tutorial on them, available at https://flaviocopes.com/javascript-regular-expressions/ .

Here are the ES2018 specific additions.

RegExp lookbehind assertions: match a string depending on what precedes it

This is a lookahead: you use ?= to match a string that's followed by a specific substring:

?! performs the inverse operation, matching if a string is not followed by a specific substring:

Lookaheads use the ?= symbol. They were already available.

Lookbehinds , a new feature, uses ?<= .

A lookbehind is negated using ?<! :

Unicode property escapes \p{…} and \P{…}

In a regular expression pattern you can use \d to match any digit, \s to match any character that's not a white space, \w to match any alphanumeric character, and so on.

This new feature extends this concept to all Unicode characters introducing \p{} and is negation \P{} .

Any unicode character has a set of properties. For example Script determines the language family, ASCII is a boolean that's true for ASCII characters, and so on. You can put this property in the graph parentheses, and the regex will check for that to be true:

ASCII_Hex_Digit is another boolean property, that checks if the string only contains valid hexadecimal digits:

There are many other boolean properties, which you just check by adding their name in the graph parentheses, including Uppercase , Lowercase , White_Space , Alphabetic , Emoji and more:

In addition to those binary properties, you can check any of the unicode character properties to match a specific value. In this example, I check if the string is written in the greek or latin alphabet:

Read more about all the properties you can use directly on the proposal .

Named capturing groups

In ES2018 a capturing group can be assigned to a name, rather than just being assigned a slot in the result array:

The s flag for regular expressions

The s flag, short for single line , causes the . to match new line characters as well. Without it, the dot matches regular characters but not the new line:

What’s next? ESNext.

ESNext is a name that always indicates the next version of JavaScript.

The current ECMAScript version is ES2018 . It was released in June 2018.

Historically JavaScript editions have been standardized during the summer, so we can expect ECMAScript 2019 to be released in summer 2019.

So at the time of writing, ES2018 has been released, and ESNext is ES2019

Proposals to the ECMAScript standard are organized in stages. Stages 1–3 are an incubator of new features, and features reaching Stage 4 are finalized as part of the new standard.

At the time of writing we have a number of features at Stage 4 . I will introduce them in this section. The latest versions of the major browsers should already implement most of those.

Some of those changes are mostly for internal use, but it’s also good to know what is going on.

There are other features at Stage 3, which might be promoted to Stage 4 in the next few months, and you can check them out on this GitHub repository: https://github.com/tc39/proposals .

Array.prototype.{flat,flatMap}

flat() is a new array instance method that can create a one-dimensional array from a multidimensional array.

By default it only “flats” up to one level, but you can add a parameter to set the number of levels you want to flat the array to. Set it to Infinity to have unlimited levels:

If you are familiar with the JavaScript map() method of an array, you know that using it you can execute a function on every element of an array.

flatMap() is a new Array instance method that combines flat() with map() . It's useful when calling a function that returns an array in the map() callback, but you want your resulted array to be flat:

Optional catch binding

Sometimes we don’t need to have a parameter bound to the catch block of a try/catch.

We previously had to do:

Even if we never had to use e to analyze the error. We can now simply omit it:

Object.fromEntries()

Objects have an entries() method, since ES2017.

It returns an array containing all the object own properties, as an array of [key, value] pairs:

ES2019 introduces a new Object.fromEntries() method, which can create a new object from such array of properties:

String.prototype.{trimStart,trimEnd}

This feature has been part of v8/Chrome for almost a year now, and it’s going to be standardized in ES2019.

trimStart()

Return a new string with removed white space from the start of the original string

Return a new string with removed white space from the end of the original string

Symbol.prototype.description

You can now retrieve the description of a symbol by accessing its description property instead of having to use the toString() method:

JSON improvements

Before this change, the line separator (\u2028) and paragraph separator (\u2029) symbols were not allowed in strings parsed as JSON.

Using JSON.parse(), those characters resulted in a SyntaxError but now they parse correctly, as defined by the JSON standard.

Well-formed JSON.stringify()

Fixes the JSON.stringify() output when it processes surrogate UTF-8 code points (U+D800 to U+DFFF).

Before this change calling JSON.stringify() would return a malformed Unicode character (a "�").

Now those surrogate code points can be safely represented as strings using JSON.stringify() , and transformed back into their original representation using JSON.parse() .

Function.prototype.toString()

Functions have always had an instance method called toString() which return a string containing the function code.

ES2019 introduced a change to the return value to avoid stripping comments and other characters like whitespace, exactly representing the function as it was defined.

If previously we had

The behavior was this:

now the new behavior is:

Wrapping up, I hope this article helped you catch up on some of the latest JavaScript additions, and the new features we’ll see in 2019.

Read more posts .

If this article was helpful, share it .

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

JS Tutorial

Js versions, js functions, js html dom, js browser bom, js web apis, js vs jquery, js graphics, js examples, js references, javascript versions.

JavaScript was invented by Brendan Eich in 1995, and became an ECMA standard in 1997.

ECMAScript is the official name of the language.

ECMAScript versions have been abbreviated to ES1, ES2, ES3, ES5, and ES6.

Since 2016, versions are named by year (ECMAScript 2016, 2017, 2018, 2019, 2020).

ECMAScript Editions

This tutorial covers every version of JavaScript:

• The Original JavaScript ES1 ES2 ES3 (1997-1999)
• The First Main Revision ES5 (2009)
• The Second Revision ES6 (2015)
• Yearly Additions (2016, 2017, 2018, 2019, 2020)

Browser Support

ECMAScript 1 - 6 is fully supported in all modern browsers.

Browser Support for ES5 (2009)

* Internet Explorer 9 does not support ECMAScript 5 "use strict".

Browser Support for ES6 (2015)

Internet Explorer does not support ECMAScript 2015.

Advertisement

Browser Support for ECMAScript 2016

COLOR PICKER

Report Error

If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:

[email protected]

Top Tutorials

Top references, top examples, get certified.

Safari is a web browser developed by Apple, based on the WebKit rendering engine and JavaScriptCore scripting runtime. It has been included with macOS since 10.3 Panther , replacing Internet Explorer for Mac as the default web browser, and with iOS since its initial release. It previously supported Windows between versions 3.0 and 5.1.7.

While Safari is an operating system component, on macOS, it can be updated independently of the core operating system. Typically, a major Safari version branch will continue to support the previous two releases of macOS, with these updates distributed via Software Update .

Version History

Safari is built into iOS, and can not be upgraded separately. Starting with iOS 14, the Safari releases closely follow those on macOS. Prior to this, it was typical that Safari on iOS would significantly lag behind macOS releases. However, on occasion, bug fixes would be backported through minor updates to the system WebKit component.

Prior to iOS 7, WebKit's text rendering functionality was used to render UIKit labels, text fields, and text views.

Safari 3 for Windows was announced by Steve Jobs at the WWDC 2007 Apple Events as a strategy for "Safari's market share to grow substantially". [2] Apple controversially used its existing install base of iTunes customers on Windows to distribute Safari 3.1 as a "recommended" update in Software Update , selected to be installed by default when the user may believe they are simply installing an iTunes update. The move was criticized by Mozilla CEO John Lilly. [3] Apple later changed Safari's Software Update entry to require the user to manually select it for installation.

Safari for Windows was silently discontinued after version 5.1.7 was released on 9 May 2012 . No official explanation was given, however it has been assumed to be a combination of its lack of success in gaining more than approximately 4.85% of desktop browser market share, and the introduction of Google Chrome in 2008, at the time being based on WebKit . [4] WebKit nightly builds continued to be released for Windows until 16 October 2012 . [5]

Safari Beta

Safari technology preview.

Safari Technology Preview is a version of Safari that is regularly updated with recent WebKit development work. It is similar to Google Chrome Dev and Firefox Developer Edition , in that a release is made every few weeks, allowing web developers to test new changes before they appear in the stable release. While the previews are typically stable, they are still not intended for general use.

• ^ a b https://github.com/mdn/browser-compat-data/blob/main/browsers/safari.json
• ^ https://www.engadget.com/2007-06-11-steve-jobs-live-from-wwdc-2007.html
• ^ http://john.jubjubs.net/2008/03/21/apple-software-update/
• ^ https://gs.statcounter.com/browser-version-market-share/desktop/worldwide/#monthly-200901-201401
• ^ https://web.archive.org/web/20130116101852/http://nightly.webkit.org/builds/trunk/win/1
• ^ a b https://www.macrumors.com/2016/03/30/apple-safari-technology-preview-browser/
• ^ https://webkit.org/blog/category/safari-technology-preview/

• Apple Watch
• Accessories
• Digital Magazine – Subscribe
• Digital Magazine – Log In
• Smart Answers
• M3 MacBook Air
• New iPad Air
• iPad mini 7
• Next Mac Pro
• Best Mac antivirus
• Best Mac VPN

When you purchase through links in our articles, we may earn a small commission. This doesn't affect our editorial independence .

Safari 17: Everything you need to know about the new macOS features

Apple’s built-in browser might be the most frequently used app on your Mac (yes, even more than the Finder, super Mac geeks). So Apple always adds helpful new features to Safari, its browser. In version 17, available with macOS Sonoma or as a separate download for macOS Ventura and Monterey, Safari helps you be more productive and secure, and it’s available for macOS Monterey, Ventura, and the upcoming Sonoma. Let’s take a look at the new features.

Safari for Mac has finally caught up with iOS and iPadOS, which have had this feature for a while. A web app is basically a website saved as a self-contained app that appears in the Dock. Just click on its icon to launch it. We have a separate guide to web apps in macOS Sonoma that details how to make and manage them.

With a profile, you can set up separate browsing sessions based on topics. For example, you can set up a Work profile for all the sites that you use for your job, and you can then set up a separate Personal profile for when you’re using the web on your own time. You can get more specific with your profiles if you want, like say, a profile for making travel plans, or another for your hobby. We have a separate guide to profiles in Safari with instructions on how to set them up.

Private Browsing enhancements

When you open a private window ( File > New Private Window , or Shift+Command+N), it opens a browser window that does not save the details of your session (such as the history), nor does it share the session with your other Apple devices. This has long been a part of Safari’s Private Browsing, but Apple has made a few more enhancements in version 17.

When a Private Window has been inactive for some time, it becomes locked and requires a user password to reopen.

• Locked Private Browsing : When a private window isn’t being used (you step away from your Mac, for example), the window locks, and its contents are hidden. To open the window, the password of the active user account must be entered.
• Link tracking protection. Websites often use trackers in links, but now when you use Private Browsing (as well as links shared in Messages and Mail), the trackers are removed.
• Advanced tracking and fingerprinting protection. Prevents known trackers from loading on pages and from identifying your device. This setting can be adjusted in Safari > Settings > Advanced , then check the box for “Use advanced tracking and fingerprinting protection.” You can always set it to work always or just when using Private Browsing.
• Extensions are turned off by default . Browser extensions can be turned on by going to Safari > Settings > Extensions and selecting the extension in the left column. Then in the main section, look for a setting checkbox for Allow in Private Browsing and check the box.

Multitab selection

Multiple tabs can be selected by holding down the Shift key and clicking on each tab. Once you have your tabs selected, Control+click, and a pop-up will appear with options on what you can do.

After selecting tabs, you can open them in a new window, create a Tab Group, and do other tasks.

Favorites bar favicons

Before version 17, the Favorites bar showed links with just text labels. Now, a favicon is included so you can quickly spot the link.

Top: the old way of how links are labeled in the Safari Favorites bar. Bottom: the new way, with Favicons.

Desktop Reading List widget

One of the key new features of macOS Sonoma is Desktop Widgets. Among the widgets you can use is a Reading List widget, which lets you access your Safari Reading List on the Desktop. Learn how to add widgets to the macOS Sonoma Desktop .

Among the new Desktop Widgets in macOS Sonoma is one for Safari’s Reading List.

Privacy protections for app extensions

Per-site privacy settings are now available for app extensions, in addition to web extensions.

One-time verification code autofill with Apple Mail

When you get a one-time verification code in Apple Mail, Safari can now grab that code for use in the browser.

Author: Roman Loyola , Senior Editor

Roman has covered technology since the early 1990s. His career started at MacUser, and he's worked for MacAddict, Mac|Life, and TechTV.

Recent stories by Roman Loyola:

• macOS 15: Everything you need to know about the next big Mac update
• New Mac malware targets users with legit-looking ads, meeting links
• Update: Apple fixes the mess it made of macOS Sonoma with the new 14.4.1 update

• Hot Tech Deals at Target Right Now
• The Best Noise-Canceling Headphones to Buy

How to Check the Version Number of Apple Safari Browser

When you need to know which Safari you're running

What To Know

• Choose Safari from the top menu, and About Safari . The version number will be on the window that pops up.
• On iOS, go to Settings > General > Software Update . Your iOS version and Safari version are the same. (Example: iOS 11 = Safari 11)

This article explains how to find the version of Safari that you're running on a Mac and an iOS device.

Find the Safari Version Number on a Mac

To determine which version of Safari is installed on a Mac computer:

Go to the dock and select the Safari icon to open the Safari browser.

Choose About Safari under the Safari menu.

A small window appears with the browser version number.

The first number, located before the parenthesis, is the current version of Safari. The longer second number (located inside the parentheses) is the WebKit/Safari Build version. For example, if the dialog box displays Version 11.0.3 (13604.5.6), the Safari version number is 11.0.3.

Find the Safari Version Number on an IOS Device

Because Safari is part of the iOS operating system, its version is the same as the current version of iOS that you have.

To see the iOS version currently installed on an iPhone or iPad, follow the instructions below.

Open Settings .

Select General .

Select Software Update . The number that appears at the top of the screen next to iOS is the version number. For example, if your iPhone or iPad is running iOS 11.2.6, then it is running Safari 11. If your device is running iOS 12.1.2, it is running Safari 12, and so on.

Underneath the version number, you'll either see "Your software is up to date" or a prompt to update to the latest version.

As of October, 2022, the current version of Safari on Mac, iPad, and iPhone is 16.0.

First, turn off automatic updates by opening System Preferences and selecting Software Update , then turning off Automatically keep my Mac up to date . After that, either restore a Time Machine backup that included an older version of Safari, or downgrade to an earlier version of macOS .

Get the Latest Tech News Delivered Every Day

• What Is Safari?
• How to Turn off Automatic Updates on Android
• List of Windows Version Numbers
• What Is a Version Number and Why Is It Used?
• Apple tvOS Versions Guide: Everything You Need to Know
• 11 Best Free Software Updater Programs
• Should I Upgrade to iOS 17?
• 10 Hidden Features in macOS Sonoma
• How to Play Android Games on iPhone
• How to Modify Text Size in the Safari Browser on a Mac
• The Top 10 Internet Browsers for 2024
• How to Check What Version of Chrome You Have
• How to Check Your Version of iOS and iPadOS
• Can You Install the Safari Browser on Android?
• Apple Safari vs. Mozilla Firefox
• Speed Up Safari With These Tuneup Tips

• iPhone SE 4
• Apple Watch
• Historia macOS

Safari: la guía definitiva. Todos los atajos, trucos y secretos del navegador de Apple

David Bernal Raspall

Safari es un navegador de renombre mundial que combina una interfaz de usuario elegante, una excelente privacidad y una velocidad de navegación rápida, lo que lo convierte en una excelente opción para aquellos que buscamos la mejor experiencia de navegación . Como con cualquier software, sin embargo, para sacar el máximo provecho de él, es necesario conocer algunos recursos, trucos y también atajos.

Hay mucho de qué hablar. Desde cómo descargar abrir y configurar Safari por primera vez, hasta atajos de teclado para navegar más rápidamente y también algún recurso para mejorar la privacidad de nuestra navegación. Sin más, repasemos todo cuanto hay que saber de Safari .

¿Qué es el Safari y para qué sirve?

Empecemos con lo básico: ¿Qué es Safari y para qué sirve? En pocas palabras, Safari es el navegador web desarrollado por Apple que viene preinstalado en todos los dispositivos de la compañía, incluyendo iPhone, iPad y Mac. Safari es ampliamente conocido por su velocidad, eficiencia, privacidad y diseño elegante, lo que lo hace una de las opciones más populares entre los usuarios de Apple.

Además de permitirnos visitar y explorar sitios web, Safari también nos permite organizar nuestros favoritos, abrir múltiples pestañas y utilizar plugins para añadir funciones útiles al navegador. Además, Safari nos ofrece una amplia gama de herramientas de privacidad y seguridad , que nos permiten navegar por la web con tranquilidad.

Safari también cuenta con una gran cantidad de herramientas de privacidad y seguridad, incluyendo la navegación privada, la gestión de contraseñas, la detección de sitios web fraudulentos, el bloqueo de ventanas emergentes y mucho más. Además, Safari se integra perfectamente con otros productos y servicios de Apple , como iCloud, Siri y Apple Pay.

¿Cómo abrir el navegador Safari?

Abrir Safari en un dispositivo de Apple es muy sencillo. En un iPhone o iPad, simplemente encontraremos la aplicación en la pantalla de inicio, de forma predeterminada ubicada en la parte inferior de la pantalla. 

Una vez que encontremos el icono de Safari, que nos muestra una brújula sobre un fondo azul , simplemente los tocamos para abrir la aplicación y comenzar a navegar. De no aparecer en la pantalla de inicio, acudamos al buscador de la biblioteca de aplicaciones, que encontraremos a la derecha de todas nuestras páginas de apps. Alternativamente, un simple "Oye Siri, abre Safari" nos puede ser también muy útil.

En un Mac, la forma más fácil de abrir Safari es a través del Dock. El Dock es la barra de aplicaciones que se encuentra en la parte inferior de la pantalla, y generalmente incluye el icono de Safari de forma predeterminada. También podemos encontrar la aplicación en la carpeta Aplicaciones, que se encuentra en el Finder. Una vez que encontremos el icono de Safari, simplemente hacemos clic o doble clic en él para abrir la aplicación. Igual que antes, podemos usar Siri para abrir la app o utilizar Spotlight para buscarla simplemente presionando Comando (⌘) + Barra espaciadora y escribiendo "Safari" en el cuadro de búsqueda.

¿Cómo descargar el navegador Safari?

Aunque esta es una pregunta frecuente, en realidad, no es posible descargar Safari, ya que el navegador viene preinstalado de forma predeterminada en todos los dispositivos que utilizan los sistemas operativos de Apple y no se puede eliminar al ser imprescindible para el sistema. Esto significa que, si tenemos un iPhone, iPad o Mac, ya tenemos Safari instalado y no necesitaremos descargarlo.

Cabe destacar que, aunque Safari antes estaba disponible para Windows, hace tiempo que esta versión se retiró . Con la intención de centrarse en el mejor desarrollo posible para el ecosistema de Apple, la descarga de Safari para Windows dejó de estar disponible hace años.

¿Cuál es mejor, Chrome o Safari?

La elección entre Safari y Chrome como navegador preferido depende de las necesidades y preferencias de cada usuario. Ambos navegadores tienen características que los hacen únicos y pueden ser utilizados en diferentes dispositivos y sistemas operativos.

Safari, como navegador de Apple, tiene una integración muy buena con otros dispositivos de la marca y es especialmente útil para usuarios de Mac, ya que utiliza menos recursos del sistema y tiene una mejor duración de la batería en comparación con otros navegadores. A la velocidad y el rendimiento se une la seguridad, pudiendo utilizar iCloud Private Relay , que podemos describir como el VPN de Apple, para navegar de forma segura a través de internet .

Por otro lado, Chrome es ampliamente utilizado y tiene una mayor cantidad de extensiones y complementos disponibles, lo que lo hace ideal para usuarios que buscan personalizar su experiencia de navegación. También tiene una mayor compatibilidad con ciertas aplicaciones y servicios de Google, como Google Drive y Gmail. En cuanto a privacidad, no podemos olvidar que Google es una empresa publicitaria y que ofrece Chrome gratuitamente a cambio de datos sobre nuestra navegación .

Diferencias entre Safari para iPhone y para Mac

Aunque tanto Safari en iPhone como en Mac sean el mismo navegador, existen algunas diferencias notables entre ambas versiones, especialmente a causa del tamaño de la pantalla. Safari para iPhone tiene un diseño más compacto y simplificado , con opciones como el botón de búsqueda y las pestañas ocultas detrás de un toque en el menú correspondiente. En cambio, la versión de Safari para Mac está diseñada para una pantalla más grande y tiene una barra de herramientas más completa y visible además de personalizable.

Otra diferencia importante entre Safari para iPhone y Mac es la forma en que se gestionan las pestañas . En la versión para iPhone, las pestañas se organizan como tarjetas, lo que hace que sea fácil de desplazarse entre ellas con un solo dedo. En cambio, en la versión para Mac, las pestañas se organizan horizontalmente en la parte superior de la ventana del navegador, lo que hace que sea fácil ver todas las pestañas abiertas de un solo vistazo y cambiar entre ellas con un simple clic.

Más allá de estos, y algunos otros, cambios en la interfaz, el motor de navegación es el mismo y las funcionalidades idénticas , por lo que tendremos la misma experiencia de navegación independientemente de qué dispositivo estemos utilizando.

Qué son los atajos en Safari

Los atajos en Safari son combinaciones de teclas que nos permiten realizar acciones específicas en el navegador de forma rápida y eficiente. En lugar de hacer clic en varios menús y opciones para realizar una tarea, podemos simplemente presionar una serie de teclas y lograr la misma tarea en mucho menos tiempo .

Si bien algunos atajos pueden variar según la versión del sistema operativo o la configuración del teclado, los más comunes son siempre los mismos. A continuación los 10 más importantes .

• Abrir una nueva pestaña: Comando (⌘) + T.
• Cerrar una pestaña: Comando (⌘) + W.
• Ir al buscador: Comando (⌘) + L.
• Guardar una página web en favoritos: Comando (⌘) + D.
• Añadir una página a la lista de lectura: Shift (⇧) + Comando (⌘) + D.
• Reabrir una pestaña cerrada: Shift (⇧) + Comando (⌘) + T.
• Ir a la página de inicio: Shift (⇧) + Comando (⌘) + H.
• Ver nuestras descargas: Comando (⌘) Option (⌥) + L.
• Ir a la siguiente pestaña: Control (⌃) + Tabulador.
• Ir a la pestaña anterior: Shift (⇧) + Control (⌃) + Tabulador.

¿Cómo pasar rápido de una pestaña a otra en Safari?

Para cambiar de pestaña en Safari en el Mac, existen varias formas. La primera es hacer clic en las pestañas en la parte superior de la ventana del navegador . También podemos utilizar los atajos de teclado Control (⌃) + Tabulador para ir a la siguiente pestaña o Shift (⇧) + Control (⌃) + Tabulador para ir a la pestaña anterior. Si tenemos muchas pestañas abiertas, podemos utilizar la vista general de pestañas tocando de exposé de pestañas tocando Shift (⇧) + Comando (⌘) + T o el botón en forma de dos cuadraditos de la parte superior derecha, y luego hacer clic en la pestaña que nos interesa.

En el iPad, para cambiar de pestaña en Safari, podemos tocar el icono de las pestañas en la esquina superior derecha de la pantalla. Desde ahí, podemos tocar en la pestaña que deseamos abrir. Alternativamente, podemos tocar una de las pestañas abiertas en la barra de pestañas.

En el iPhone, el proceso es muy similar al del iPad. Podemos tocar el icono de las pestañas en la esquina inferior derecha y luego tocar en la pestaña que deseamos abrir. También podemos deslizar el dedo hacia la izquierda o hacia la derecha encima de la barra de dirección de la parte inferior para cambiar entre las pestañas abiertas.

¿Cómo poner el modo secreto en Safari?

En Safari, el modo secreto, al que llamamos navegación privada nos permite navegar por la web sin que se guarden datos como el historial, las cookies o los términos de búsqueda . Para activar esta función en el iPhone y el iPad, basta con abrir Safari y tocar el botón de pestañas en forma de dos cuadraditos. A continuación, tocamos en Página principal si no tenemos ninguna abierta, o en X pestañas si las tenemos abiertas y seleccionar Nav. privada .

También hay una manera rápida de activar la navegación privada sin tener que pasar por el menú de pestañas. Simplemente mantenemos presionado el icono de Safari en la pantalla de inicio hasta que aparezca un menú emergente y luego tocamos en "Nueva pestaña privada".

En el Mac, se puede activar la navegación privada haciendo clic en el menú Archivo en la barra de menús y luego seleccionando Nueva ventana privada . También podemos utilizar la combinación de teclas Shift (⇧) + Comando (⌘) + N .

Safari es mucho más que un simple navegador web. Es una herramienta que nos permite explorar y descubrir todo lo que internet tiene para ofrecernos . Desde el simple acto de abrir una pestaña y visitar una página, hasta la posibilidad de crear y organizar nuestros propios favoritos. Con su enfoque en la privacidad y la seguridad que nos da la tranquilidad a la hora de navegar con nuestros datos a salvo, ya hablemos del iPhone, del iPad o del Mac, nuestra mejor opción para surcar internet es Safari.

En Applesfera | iOS 16: principales características, cómo descargarlo y modelos compatibles

• Navegadores Web
• Navegador iOS

Los mejores comentarios:

Ver 6 comentarios

• iCloud fotos
• iPhone 14 pro
• Qué iPhone comprar
• Chat GPT Iphone
• Qué iPad comprar
• Qué Mac comprar
• MacBook Air M2
• Apple Watch 9
• Saber si mi iPhone tiene virus
• Conectar airpods a PC
• iPad Pro 2023
• Xataka Móvil
• Xataka Android
• Xataka Smart Home
• Mundo Xiaomi

Videojuegos

• 3DJuegos PC
• 3DJuegos Guías

Entretenimiento

Gastronomía

• Directo al Paladar

Estilo de vida

• Trendencias
• Compradiccion

Latinoamérica

• Xataka México
• 3DJuegos LATAM
• Sensacine México
• Directo al Paladar México
• Premios Xataka

Recibe "Xatakaletter", nuestra newsletter semanal

Explora en nuestros medios.

• Cinco auriculares Bluetooth ideales para regalar el Día de la Madre
• He probado el "nuevo" Amazon Prime Video con anuncios en mi iPhone. Quitarlos cuesta un dineral, aunque puede ser rentable
• Uno de los RPG de acción más sublimes de la generación y mi primer claro candidato al GOTY. Análisis definitivo de Dragon's Dogma 2 en Vidaextra
• Hay 3634 calculadoras online gratuitas. Esto es todo lo que puedes calcular con ellas sin salir del iPhone
• Desmantelan el mayor alijo de productos Apple falsificados y que esconde una oscura trama detrás
• La turbia historia detrás del ex-ingeniero de Apple que robó todos los secretos del Apple Car para vendérselos a China
• Otterbox liquida sus fundas para iPhone ultrarresistentes para proteger a tope el teléfono de Apple
• Las 10 novedades con las que el iPhone SE 4 pretende revolucionar el mercado del móvil gama media
• Este usuario ha creado en cinco minutos esta genial aplicación para la App Store usando GPT-4
• Las tortitas de la tía May de Spider-Man son el nuevo debate en Marvel por culpa de una nota casi ilegible de Stan Lee en Vidaextra
• Qué es Testflight, el paraíso de las aplicaciones beta para iPhone
• Por qué Hacienda no me ha devuelto todavía el pago de la Renta 2023 y cómo consultar desde el iPhone cuándo se hará
• Tras un mes de iOS 17.4, este es el estado de las tiendas alternativas a la App Store. Una promesa a medias
• Elon Musk tiene claro cuándo superará la IA a la inteligencia humana. Es una predicción alarmante en Xataka
• La mejor lavadora según la OCU también era la favorita de Steve Jobs, pero no porque lavara bien la ropa
• Tecnología asequible en Lidl: enchufes y luces "inteligentes", cargador con altavoz para iPhone y más
• Los mejores DNS de 2024: las más rápidas y seguras en Genbeta
• ¿Se daña la cámara? Qué sucede si ves o grabas con el iPhone un eclipse solar como el de México
• Forzar el reinicio del iPhone y apagar y volver a encenderlo: cuál es la diferencia crucial Por si te lo perdiste

Ver más artículos

Applesfera TV

Ver más vídeos

Want to highlight a helpful answer? Upvote!

Did someone help you, or did an answer or User Tip resolve your issue? Upvote by selecting the upvote arrow. Your feedback helps others!  Learn more about when to upvote >

what version of Safari is running on macOS Big Sur 11.7.10?

I currently have Big Sur v.11.5 on my 2020 macBook Air and have started having issues with my version of Safari (v.14.1.2) and would like to update Safari. 

Software update on my macBook offers an macOS update to Big Sur v.11.7.10 (as well as an update to Sonoma 14.4.1).

I’m not ready to try updating all the way to Sonoma, so I was hoping Big Sur 11.7.10 would be an easier update and include an update from my current Safari v.14.1.2.

Posted on Apr 4, 2024 3:19 AM

Loading page content

Page content loaded

Apr 4, 2024 8:20 AM in response to dnalsigib

Big Sur 11.7.10 includes Safari 16.6.1.

Personally, I would upgrade to Sonoma but you could also upgrade to Monterey or Ventura.

Monterey, Ventura and Sonoma all include the latest version of Safari, 17.4.1.

To upgrade, have a current backup (a good idea even when not upgrading) and see:

How to download and install macOS - Apple Support

or:  How to upgrade to macOS Sonoma - Apple Support

Apr 4, 2024 6:57 PM in response to FoxFifth

Thank you. I’m a bit nervous about updating all the way to Sonoma 14.1.2 from Big Sur 11.5. Is that typically the best way to do it, rather than updating a little at a time?

I’m afraid something will stop working. 

Apr 5, 2024 8:16 AM in response to dnalsigib

I normally update/upgrade as soon as the new version is available but you shouldn't have any issue updating directly to Sonoma. As stated in my previous reply you can also upgrade to Monterey or Ventura.

Either way you choose to do it, you should have a backup first (a good idea at all times).

Apr 5, 2024 10:37 PM in response to FoxFifth

Thank you very much for your help.

• One more thing

¿Cuál es la última versión de Safari en Mac a enero de 2022?

Si no hace mucho tiempo que tienes un Mac o simplemente desconoces lo referente a las versiones de Safari, muy probablemente tengas dudas acerca de si lo has actualizado. Teniendo en cuenta las interesantes novedades que ha introducido en los últimos meses, querrás tenerlo a la última. Pues bien, ¿cómo puedes saber si tienes el navegador actualizado o no?

Safari no se actualiza como tal

Lo primero que debes saber es que, a diferencia de algunas otras aplicaciones, el navegador del Mac no suele lanzar actualizaciones mediante la App Store. Las nuevas versiones de Safari se integran en las actualizaciones de macOS , de tal forma que cuando actualices el sistema operativo, se actualice con ello también esta aplicación, así como algunas otras herramientas nativas.

No quiere decir esto que con cada actualización del Mac se añadan también nuevas versiones de Safari o que estas vengan cargadas de novedades. Sin embargo, lo cierto es que siempre suelen traer algo nuevo, sea más o menos destacable. Y esto es especialmente apreciable en el área de la seguridad, ya que la compañía californiana pone especial mimo a este navegador por ser la puerta de entrada de la mayoría de malware y por ende precisa de estar siempre con los últimos parches que cubran posibles vulnerabilidades.

A día de hoy, la última versión es la 15.2 . Esta no solo integra todas las novedades de Safari de macOS Monterey que ya vimos en su lanzamiento original, sino que incluye también los parches de seguridad más avanzados con los que navegar de forma segura. Por tanto, si quieres asegurarte de tener esta versión, solo tienes que abrir el navegador, ir a la barra de menús, pulsar sobre ‘Safari’ y después en ‘Acerca de Safari’.

Actualizaciones de Safari para «viejos» macOS

Si hay algo por lo que esté destacando Safari en estos últimos años es por no dejar atrás a todos los Mac que ya no se pueden actualizar. Safari 15, con todas sus novedades en referencia a gestión de pestañas o nueva interfaz, está también disponible en aquellos ordenadores que ya no soportan macOS Monterey, pero sí podían actualizar a Big Sur. La forma de descargarlo es mediante Preferencias del Sistema como comentábamos previamente.

Estos son los Mac que no pueden actualizarse a macOS Monterey, pero sí a Big Sur y a estas últimas versiones de Safari:

• iMac lanzados en 2014
• MacBook lanzados en 2015
• MacBook Air lanzados en 2013 y 2014
• MacBook Pro lanzados a finales de 2013 y en 2014

Por descontado queda que el resto de ordenadores de la marca que además son más recientes pueden también actualizar a macOS Monterey y con ello a todas las actualizaciones de Safari que llegarán con las sucesivas versiones.

Navegar por lamanzanamordida.net con publicidad personalizada, seguimiento y cookies de forma gratuita. i

Para ello, nosotros y nuestros socios i necesitamos tu consentimiento i para el tratamiento de datos personales i para los siguientes fines:

Las cookies, los identificadores de dispositivos o los identificadores online de similares características (p. ej., los identificadores basados en inicio de sesión, los identificadores asignados aleatoriamente, los identificadores basados en la red), junto con otra información (p. ej., la información y el tipo del navegador, el idioma, el tamaño de la pantalla, las tecnologías compatibles, etc.), pueden almacenarse o leerse en tu dispositivo a fin de reconocerlo siempre que se conecte a una aplicación o a una página web para una o varias de los finalidades que se recogen en el presente texto.

La mayoría de las finalidades que se explican en este texto dependen del almacenamiento o del acceso a la información de tu dispositivo cuando utilizas una aplicación o visitas una página web. Por ejemplo, es posible que un proveedor o un editor/medio de comunicación necesiten almacenar una cookie en tu dispositivo la primera vez que visite una página web a fin de poder reconocer tu dispositivo las próximas veces que vuelva a visitarla (accediendo a esta cookie cada vez que lo haga).

La publicidad y el contenido pueden personalizarse basándose en tu perfil. Tu actividad en este servicio puede utilizarse para crear o mejorar un perfil sobre tu persona para recibir publicidad o contenido personalizados. El rendimiento de la publicidad y del contenido puede medirse. Los informes pueden generarse en función de tu actividad y la de otros usuarios. Tu actividad en este servicio puede ayudar a desarrollar y mejorar productos y servicios.

La publicidad que se presenta en este servicio puede basarse en datos limitados, tales como la página web o la aplicación que esté utilizando, tu ubicación no precisa, el tipo de dispositivo o el contenido con el que está interactuando (o con el que ha interactuado) (por ejemplo, para limitar el número de veces que se presenta un anuncio concreto).

• Un fabricante de automóviles quiere promocionar sus vehículos eléctricos a los usuarios respetuosos con el medioambiente que viven en la ciudad fuera del horario laboral. La publicidad se presenta en una página con contenido relacionado (como un artículo sobre medidas contra el cambio climático) después de las 18:30 h a los usuarios cuya ubicación no precisa sugiera que se encuentran en una zona urbana.
• Un importante fabricante de acuarelas quiere realizar una campaña publicitaria en Internet para dar a conocer su última gama de acuarelas con la finalidad de llegar tanto a artistas aficionados como a profesionales y, a su vez, se evite mostrar el anuncio junto a otro contenido no relacionado (por ejemplo, artículos sobre cómo pintar una casa). Se detectará y limitará el número de veces que se ha presentado el anuncio a fin de no mostrarlo demasiadas veces.

La información sobre tu actividad en este servicio (por ejemplo, los formularios que rellenes, el contenido que estás consumiendo) puede almacenarse y combinarse con otra información que se tenga sobre tu persona o sobre usuarios similares(por ejemplo, información sobre tu actividad previa en este servicio y en otras páginas web o aplicaciones). Posteriormente, esto se utilizará para crear o mejorar un perfil sobre tu persona (que podría incluir posibles intereses y aspectos personales). Tu perfil puede utilizarse (también en un momento posterior) para mostrarte publicidad que pueda parecerte más relevante en función de tus posibles intereses, ya sea por parte nuestra o de terceros.

• En una plataforma de redes sociales has leído varios artículos sobre cómo construir una casa en un árbol Esta información podría añadirse a un perfil determinado para indicar tuinterés en el contenido relacionado con la naturaleza, así como en los tutoriales de bricolaje (con el objetivo de permitir la personalización del contenido, de modo que en el futuro, por ejemplo, se te muestren más publicaciones de blogs y artículos sobre casas en árboles y cabañas de madera).
• Has visualizado tres vídeos sobre la exploración espacial en diferentes aplicaciones de televisión. Una plataforma de noticias sin relación con las anteriores y con la que no has tenido contacto en el pasado crea un perfil basado en esa conducta de visualización marcando la exploración del espacio como un tema de tu posible interés para para otros vídeos.

El contenido que se te presenta en este servicio puede basarse en un perfilde personalización de contenido que se haya realizado previamente sobre tu persona, lo que puede reflejar tu actividad en este u otros servicios (por ejemplo, los formularios con los que interactúas o el contenido que visualizas), tus posibles intereses y aspectos personales. Un ejemplo de lo anterior sería la adaptación del orden en el que se te presenta el contenido, para que así te resulte más sencillo encontrar el contenido (no publicitario) que coincida con tus intereses.

• Has leído unos artículos sobre comida vegetariana en una plataforma de redes sociales. Posteriormente has usado una aplicación de cocina de una empresa sin relación con la anterior plataforma. El perfil que se ha creado sobre tu persona en la plataforma de redes sociales se utilizará para mostrarte recetas vegetarianas en la pantalla de bienvenida de la aplicación de cocina.
• Has visualizado tres vídeos sobre remo en páginas web diferentes. Una plataforma de video, no relacionada con la página web en la que has visualizado los vídeos sobre remo, pero basandose en el perfil creado cuando visistaste dicha web, podrá recomendarte otros 5 vídeos sobre remo cuando utilices la plataforma de video a través de tu televisor .
• Has hecho clic en un anuncio en una página web/medio de comunicación sobre descuentos realizados por una tienda online con motivo del “Black Friday” online y posteriormente has comprado un producto. Ese clic que has hecho estará vinculado a esa compra. Tu interacción y la de otros usuarios se medirán para saber el número de clics en el anuncio que han terminado en compra.
• Usted es una de las pocas personas que ha hecho clic en un anuncio que promociona un descuento por el “Día de la madre”de una tienda de regalos en Internet dentro de la aplicación de una web/medio de comunicación. El medio de comunicación quiere contar con informes para comprender con qué frecuencia usted y otros usuarios han visualizado o han hecho clic en un anuncio determinado dentro de la aplicación y, en particular, en el anuncio del “Día de la madre” para así ayudar al medio de comunicación y a sus socios (por ejemplo, las agencias de publicidad) a optimizar la ubicación de los anuncios.

La información sobre qué contenido se te presenta y sobre la forma en que interactúas con él puede utilizarse para determinar, por ejemplo, si el contenido (no publicitario) ha llegado a su público previsto y ha coincidido con sus intereses. Por ejemplo, si hasleído un artículo, si has visualizado un vídeo, si has escuchado un “pódcast” o si has consultado la descripción de un producto, cuánto tiempo has pasado en esos servicios y en las páginas web que has visitado, etc. Esto resulta muy útil para comprender la relevancia del contenido (no publicitario) que se te muestra.

• Has leído una publicación en un blog sobre senderismo desde la aplicación móvil de un editor/medio de comunicación y has seguido un enlace a una publicación recomendada y relacionada con esa publicación. Tus interacciones se registrarán para indicar que la publicación inicial sobre senderismo te ha resultado útil y que la misma ha tenido éxito a la hora de ganarse tu interés en la publicación relacionada. Esto se medirá para saber si deben publicarse más contenidos sobre senderismo en el futuro y para saber dónde emplazarlos en la pantalla de inicio de la aplicación móvil.
• Se te ha presentado un vídeo sobre tendencias de moda, pero tu y otros usuarios habéis dejado de visualizarlo transcurridos unos 30 segundos. Esta información se utilizará para valorar la duración óptima de los futuros vídeos sobre tendencias de moda.

Se pueden generar informes basados en la combinación de conjuntos de datos (como perfiles de usuario, estadísticas, estudios de mercado, datos analíticos) respecto a tus interacciones y las de otros usuarios con el contenido publicitario (o no publicitario) para identificar las características comunes (por ejemplo, para determinar qué público objetivo es más receptivo a una campaña publicitaria o a ciertos contenidos).

• El propietario de una librería que opera en Internet quiere contar con informes comerciales que muestren la proporción de visitantes que han visitado su página y se han ido sin comprar nada o que han consultado y comprado la última autobiografía publicada, así como la edad media y la distribución de género para cada uno de los dos grupos de visitantes. Posteriormente, los datos relacionados con la navegación que realizas en su página y sobre tus características personales se utilizan y combinan con otros datos para crear estas estadísticas.
• Un anunciante quiere tener una mayor comprensión del tipo de público que interactúa con sus anuncios. Por ello, acude a un instituto de investigación con el fin de comparar las características de los usuarios que han interactuado con el anuncio con los atributos típicos de usuarios de plataformas similares en diferentes dispositivos. Esta comparación revela al anunciante que su público publicitario está accediendo principalmente a los anuncios a través de dispositivos móviles y que es probable que su rango de edad se encuentre entre los 45 y los 60 años.

La información sobre tu actividad en este servicio, como tu interacción con los anuncios o con el contenido, puede resultar muy útil para mejorar productos y servicios, así como para crear otros nuevos en base a las interacciones de los usuarios, el tipo de audiencia, etc. Esta finalidad específica no incluye el desarrollo ni la mejora de los perfiles de usuario y de identificadores.

• Una plataforma tecnológica que opera con un proveedor de redes sociales observa un crecimiento en los usuarios de aplicaciones móviles y se da cuenta de que, en funciónde sus perfiles, muchos de ellos se conectan a través de conexiones móviles. La plataforma utiliza una tecnología nueva para mostrar anuncios con un formato óptimo para los dispositivos móviles y con un ancho de banda bajo a fin de mejorar su rendimiento.
• Un anunciante está buscando una forma de mostrar anuncios en un nuevo tipo de dispositivo. El anunciante recopila información sobre la forma en que los usuarios interactúan con este nuevo tipo de dispositivo con el fin de determinar si puede crear un nuevo mecanismo para mostrar la publicidad en ese tipo de dispositivo.

El contenido que se presenta en este servicio puede basarse en datos limitados, como por ejemplo la página web o la aplicación que esté utilizando, tu ubicación no precisa, el tipo de dispositivo o el contenido con el que estás interactuando (o con el que has interactuado) (por ejemplo, para limitar el número de veces que se te presenta un vídeo o un artículo en concreto).

• Una revista de viajes, para mejorar las experiencias de viaje en el extranjero, ha publicado en su página web un artículo sobre nuevos cursos que ofrece una escuela de idiomas por Internet. Las publicaciones del blog de la escuela se insertan directamente en la parte inferior de la página y se seleccionan en función de la ubicación no precisa del usuario (por ejemplo, publicaciones del blog que explican el plan de estudios del curso para idiomas diferentes al del país en el que este te encuentras).
• Una aplicación móvil de noticias deportivas ha iniciado una nueva sección de artículos sobre los últimos partidos de fútbol. Cada artículo incluye vídeos alojados por una plataforma de streaming independiente que muestra los aspectos destacados de cada partido. Si adelantas un vídeo, esta información puede utilizarse para determinar que el siguiente vídeo a reproducir sea de menor duración.

Se puede utilizar la localización geográfica precisa y la información sobre las características del dispositivo

Al contar con tu aprobación, tu ubicación exacta (dentro de un radio inferior a 500 metros) podrá utilizarse para apoyar las finalidades que se explican en este documento.

Con tu aceptación, se pueden solicitar y utilizar ciertas características específicas de tu dispositivo para distinguirlo de otros (por ejemplo, las fuentes o complementos instalados y la resolución de su pantalla) en apoyo de las finalidades que se explican en este documento.

Por solo 1,67€ al mes, disfruta de una navegación sin interrupciones por toda la red del Grupo ADSLZone: adslzone.net, movilzona.es, testdevelocidad.es, lamanzanamordida.net, hardzone.es, softzone.es, redeszone.net, topesdegama.com y más. Al unirte a nuestra comunidad, no solo estarás apoyando nuestro trabajo, sino que también te beneficiarás de una experiencia online sin cookies.

En un minuto: Louisiana avanza en su propia versión de la polémica ley SB4 de Texas

En un minuto: Millones de personas esperan ver el eclipse total de sol en buena parte de EEUU

55 tornados en menos de 24 horas: las imágenes de la devastación en el este de EEUU

¿Por qué es imposible predecir los terremotos?

Las imágenes del terremoto de magnitud 4.8 en Nueva York y el noreste de EEUU

Sin luz y con cortes de carreteras: los efectos de nevadas y vientos de más de 40 mph en el noreste

En un minuto: El Noreste es azotado con fuertes vientos, intensas nevadas y lluvias torrenciales

Una mujer estadounidense de 79 años muere pisoteada por un elefante en Zambia durante un safari

Hispana teme que recorten sus horas de trabajo tras el alza del salario mínimo a $20 en California

Trump vuelve a insultar y a desinformar sobre inmigrantes: los llama "animales" y "asesinos"

Dueños del barco que tiró el puente en Baltimore usan ‘Ley Titanic’ para no pagar una fortuna

Tus historias favoritas están en vix.

Blazing fast. Incredibly private.

Safari is the best way to experience the internet on all your Apple devices. It brings robust customization options, powerful privacy protections, and industry-leading battery life — so you can browse how you like, when you like. And when it comes to speed, it’s the world’s fastest browser. 1

Performance

More with the battery. less with the loading..

With a blazing-fast JavaScript engine, Safari is the world’s fastest browser. 1 It’s developed to run specifically on Apple devices, so it’s geared to make the most out of your battery life and deliver long-lasting power. And with Apple silicon, it’s even faster than ever before. 2

Increased performance

We’re always working to make the fastest desktop browser on the planet even faster.

Improved power efficiency

Safari lets you do more online on a single charge.

Up to 2 hours more streaming videos compared with Chrome, Edge, and Firefox 4

Up to 17 hours of wireless browsing 4

Best-in-class browsing

Safari outperforms both Mac and PC browsers in benchmark after benchmark on the same Mac. 5

• JetStream /
• MotionMark /
• Speedometer /

JavaScript performance on advanced web applications. 5

Safari vs. other Mac browsers

Safari on macOS

Chrome on macOS

Edge on macOS

Firefox on macOS

Safari vs. Windows 11 browsers

Chrome on Windows 11

Edge on Windows 11

Firefox on Windows 11

Rendering performance of animated content. 5

Web application responsiveness. 5

4K video streaming

See your favorite shows and films in their best light. Safari supports in-browser 4K HDR video playback for YouTube, Netflix, and Apple TV+. 6 And it runs efficiently for longer-lasting battery life.

Privacy is built in.

Online privacy isn’t just something you should hope for — it’s something you should expect. That’s why Safari comes with industry-leading privacy protection technology built in, including Intelligent Tracking Prevention that identifies trackers and helps prevent them from profiling or following you across the web. Upgrading to iCloud+ gives you even more privacy protections, including the ability to sign up for websites and services without having to share your personal email address.

Intelligent Tracking Prevention

Safari stops trackers in their tracks.

What you browse is no one’s business but your own. Safari has built‑in protections to help stop websites and data-collection companies from watching and profiling you based on your browsing activity. Intelligent Tracking Prevention uses on-device intelligence to help prevent cross-site tracking and stops known trackers from using your IP address — making it incredibly difficult to learn who you are and what you’re interested in.

Privacy Report

Safari makes it simple to see how your privacy is protected on all the websites you visit. Click the Privacy Report button in your toolbar for a snapshot of cross-site trackers currently prevented from profiling you on the website you’re visiting. Or view a weekly Privacy Report to see how Safari protects you as you browse over time.

Customization

Putting the you in url..

Safari is more customizable than ever. Organize your tabs into Tab Groups so it’s easy to go from one interest to the next. Set a custom background image and fine-tune your browser window with your favorite features — like Reading List, Favorites, iCloud Tabs, and Siri Suggestions. And third-party extensions for iPhone, iPad, and Mac let you do even more with Safari, so you can browse the way you want across all your devices.

Save and organize your tabs in the way that works best for you. Name your Tab Groups, edit them, and switch among them across devices. You can also share Tab Groups — making planning your next family trip or group project easier and more collaborative.

Safari Extensions add functionality to your browser to help you explore the web the way you want. Find and add your favorite extensions in the dedicated Safari category on the App Store.

Smart Tools

Designed to help your work flow..

Built-in tools create a browsing experience that’s far more immersive, intuitive, and immediate. Get detailed information about a subject in a photo with just a click, select text within any image, instantly translate an entire web page, and quickly take notes wherever you are on a site — without having to switch apps.

Notes is your go-to app to capture any thought. And with the new Quick Note feature, you can instantly jot down ideas as you browse websites without having to leave Safari.

Translation

Translate entire web pages between 18 languages with a single click. You can also translate text in images and paused video without leaving Safari.

Interact with text in any image on the web using functions like copy and paste, lookup, and translate. 7

Visual Look Up

Quickly learn more about landmarks, works of art, breeds of dogs, and more with only a photo or an image you find online. 8 And easily lift the subject of an image from Safari, remove its background, and paste it into Messages, Notes, or other apps.

Surf safe and sound.

Strong security protections in Safari help keep you safe. Passkeys introduce a safer way to sign in. iCloud Keychain securely stores and autofills passkeys and passwords across all your devices. Safari also notifies you when it encounters suspicious websites and prevents them from loading. Because it loads each web page in a separate process, any harmful code is always confined to a single browser tab so it won’t crash the entire application or access your data. And Safari automatically upgrades sites from HTTP to the more secure HTTPS when available.

Passkeys introduce a more secure and easier way to sign in. No passwords required.

Passkeys are end-to-end encrypted and safe from phishing and data leaks, and they are stronger than all common two-factor authentication types. Thanks to iCloud Keychain, they work across all your Apple devices, and they even work on non-Apple devices.

Learn more about passkeys

Wallet make checkout as easy as lifting a finger.

With AutoFill, you can easily fill in your previously saved credit card information from the Wallet app during checkout. Your credit card details are never shared, and your transactions are protected with industry-leading security.

Same Safari. Different device.

Safari works seamlessly and syncs your passwords, bookmarks, history, tabs, and more across Mac, iPad, iPhone, and Apple Watch. And when your Mac, iOS, or iPadOS devices are near each other, they can automatically pass what you’re doing in Safari from one device to another using Handoff. You can even copy images, video, or text from Safari on your iPhone or iPad, then paste into another app on your nearby Mac — or vice versa.

When you use Safari on multiple devices, your tabs carry over from one Apple device to another. So you can search, shop, work, or browse on your iPhone, then switch to your iPad or Mac and pick up right where you left off.

Save web pages you want to read later by adding them to your Reading List. Then view them on any of your iCloud-connected devices — even if you’re not connected to the internet.

iCloud Keychain securely stores your user names, passkeys, passwords, and credit card numbers and keeps them up to date on your trusted devices. So you can easily sign in to your favorite websites — as well as apps on iOS and iPadOS — and quickly make online purchases.

Designed for developers.

Deep WebKit integration between Mac hardware and macOS allows Safari to deliver the fastest performance and the longest battery life of any browser on the platform, while supporting modern web standards for rich experiences in the browser. WebKit in macOS Ventura includes optimizations that enable even richer browsing experiences, and give developers more control over styling and layout — allowing for more engaging content.

Make Safari your default browser

Customize your start page, view your browsing privacy report, monitor your saved passwords, view your tabs across all your devices, read the safari user guide, get safari support.

.NET April 2024 Updates – .NET 8.0.4, 7.0.18, .NET 6.0.29

Rahul Bhandari (MSFT)

April 9th, 2024 0 1

Today, we are releasing the .NET April 2024 Updates . These updates contain security and non-security improvements. Your app may be vulnerable if you have not deployed a recent .NET update.

You can download 8.0.4 , 7.0.18 and, 6.0.29 versions for Windows, macOS, and Linux, for x86, x64, Arm32, and Arm64.

• Installers and binaries: 8.0.4 | 7.0.18 | 6.0.29
• Release notes: 8.0.4 | 7.0.18 | 6.0.29
• Container images
• Linux packages: 8.0.4 | 7.0.18 | 6.0.29
• Release feedback/issue
• Known issues: 8.0 | 7.0 | 6.0

Windows Package Manager CLI (winget)

You can now install .NET updates using the Windows Package Manager CLI (winget):

• To install the .NET 8 runtime: winget install dotnet-runtime-8
• To install the .NET 8 SDK: winget install dotnet-sdk-8
• To update an existing installation: winget upgrade

See Install with Windows Package Manager (winget) for more information.

Improvements

• ASP.NET Core: 8.0.4 | 6.0.29
• Entity Framework Core: 8.0.4
• Runtime: 8.0.4 | 7.0.18 | 6.0.29

CVE-2024-21409 | .NET Elevation of Privilege Vulnerability

Microsoft is releasing this security advisory to provide information about a vulnerability in .NET 6.0, .NET 7.0 ,and .NET 8.0. This advisory also provides guidance on what developers can do to update their applications to remove this vulnerability.

A use-after-free vulnerability exists in WPF which may result in Elevation of Privilege when viewing untrusted documents.

Visual Studio

See release notes for Visual Studio compatibility for .NET 8.0 , .NET 7.0 and, .NET 6.0 .

Rahul Bhandari (MSFT) Program Manager, .NET

Leave a comment Cancel reply

Log in to start the discussion.

Insert/edit link

Enter the destination URL

Or link to existing content

Actualizar el iPhone o iPad

Obtén información sobre cómo actualizar el iPhone o iPad a la versión más reciente de iOS o iPadOS.

Puedes actualizar el iPhone o iPad a la versión más reciente de iOS o iPadOS de forma inalámbrica.

Si la actualización no aparece en el dispositivo, usa la computadora para actualizarlo manualmente. Obtén información sobre cómo actualizar el dispositivo de forma manual si usas una Mac con macOS Catalina o versiones posteriores, o si usas una Mac con macOS Mojave o versiones anteriores, o una PC con Windows .

Actualizar el iPhone o iPad de forma inalámbrica

Realiza un respaldo del contenido de tu dispositivo con iCloud o una computadora.

Conecta el dispositivo a una fuente de alimentación y a Internet con Wi-Fi .

Ve a Configuración > General y, luego, toca Actualización de software.

Si aparece más de una opción de actualización de software disponible, selecciona la que desees instalar.

Toca Instalar ahora. Si aparece la opción Descargar e instalar, tócala para descargar la actualización, ingresa el código y, luego, toca Instalar ahora. Obtén información sobre qué hacer si olvidaste el código .

Si aparece una alerta al actualizar el sistema de forma inalámbrica

Obtén información sobre qué hacer si aparece un mensaje de alerta al intentar actualizar el dispositivo de forma inalámbrica .

Algunas actualizaciones de software no están disponibles de forma inalámbrica. Es posible que las conexiones VPN y proxy impidan que el dispositivo se conecte a los servidores de actualización.

Si necesitas más espacio al actualizar el sistema de forma inalámbrica

Si aparece un mensaje en el que se indica que debes eliminar apps temporalmente debido a que el software necesita más espacio para la actualización, toca Continuar para permitir que se eliminen las apps. Una vez completada la instalación, estas apps se volverán a instalar automáticamente. Si tocas Cancelar, puedes  eliminar contenido de forma manual  del dispositivo para tener más espacio.

Personalizar las actualizaciones automáticas

El dispositivo puede actualizarse automáticamente durante la noche mientras se carga.

Activar las actualizaciones automáticas

Ve a Configuración > General > Actualización de software.

Toca Actualizaciones automáticas y, luego, activa Descargar actualizaciones de iOS.

Activa Instalar actualizaciones de iOS. Tu dispositivo se actualiza automáticamente a la versión más reciente de iOS o iPadOS. Es posible que algunas actualizaciones se deban instalar de forma manual.

Instalar las respuestas rápidas de seguridad

Las respuestas rápidas de seguridad ofrecen importantes mejoras de seguridad más rápido, antes de que se incluyan en futuras actualizaciones de software.

Para obtener respuestas rápidas de seguridad automáticamente, haz lo siguiente:

Toca Actualización automática.

Asegúrate de que la opción Respuestas de seguridad y archivos del sistema esté activada.

Si no deseas que las respuestas rápidas de seguridad se instalen automáticamente, puedes instalar las respuestas rápidas de seguridad como actualizaciones de software .

Si tienes que eliminar una respuesta rápida de seguridad:

Ve a Configuración > General > Información.

Toca Versión de iOS.

Toca Eliminar respuesta de seguridad.

Puedes reinstalar la respuesta rápida de seguridad más tarde o esperar a que se instale permanentemente como parte de una actualización de software estándar.

Cuando se actualiza un dispositivo a la versión más reciente del software de iOS o iPadOS, se obtienen las últimas funciones, actualizaciones de seguridad y correcciones de errores. No todas las funciones están disponibles en todos los dispositivos o en todos los países y regiones. Es posible que el rendimiento de la batería y el sistema se vea influenciado por varios factores, como el estado de la red y el uso individual del dispositivo. Los resultados reales pueden variar.

Contactar con el Soporte técnico de Apple

¿Necesitas ayuda? Ahorra tiempo iniciando una solicitud en línea al soporte técnico y te pondremos en contacto con un experto.

Windows 11, version 23H2

April 9, 2024—kb5036893 (os builds 22621.3447 and 22631.3447).

• March 26, 2024—KB5035942 (OS Builds 22621.3374 and 22631.3374) Preview
• March 12, 2024—KB5035853 (OS Builds 22621.3296 and 22631.3296)
• February 29, 2024—KB5034848 (OS Builds 22621.3235 and 22631.3235) Preview
• February 13, 2024—KB5034765 (OS Builds 22621.3155 and 22631.3155)
• January 23, 2024—KB5034204 (OS Builds 22621.3085 and 22631.3085) Preview
• January 9, 2024—KB5034123 (OS Builds 22621.3007 and 22631.3007)
• December 12, 2023—KB5033375 (OS Builds 22621.2861 and 22631.2861)
• December 4, 2023—KB5032288 (OS Builds 22621.2792 and 22631.2792) Preview
• November 14, 2023—KB5032190 (OS Builds 22621.2715 and 22631.2715)
• October 31, 2023—KB5031455 (OS Builds 22621.2506 and 22631.2506) Preview

Windows 11, version 22H2

• October 10, 2023—KB5031354 (OS Build 22621.2428)
• September 26, 2023—KB5030310 (OS Build 22621.2361) Preview
• September 12, 2023—KB5030219 (OS Build 22621.2283)
• August 22, 2023—KB5029351 (OS Build 22621.2215) Preview
• August 8, 2023—KB5029263 (OS Build 22621.2134)
• July 26, 2023—KB5028254 (OS Build 22621.2070) Preview
• July 11, 2023—KB5028185 (OS Build 22621.1992)
• June 27, 2023—KB5027303 (OS Build 22621.1928) Preview
• June 13, 2023—KB5027231 (OS Build 22621.1848)
• May 24, 2023—KB5026446 (OS Build 22621.1778) Preview
• May 9, 2023—KB5026372 (OS Build 22621.1702)
• April 25, 2023—KB5025305 (OS Build 22621.1635) Preview
• April 11, 2023—KB5025239 (OS Build 22621.1555)
• March 28, 2023—KB5023778 (OS Build 22621.1485) Preview
• March 14, 2023—KB5023706 (OS Build 22621.1413)
• February 28, 2023—KB5022913 (OS Build 22621.1344) Preview
• February 14, 2023—KB5022845 (OS Build 22621.1265)
• January 26, 2023—KB5022360 (OS Build 22621.1194) Preview
• January 10, 2023—KB5022303 (OS Build 22621.1105)
• December 13, 2022—KB5021255 (OS Build 22621.963)
• November 29, 2022—KB5020044 (OS Build 22621.900) Preview
• November 8, 2022—KB5019980 (OS Build 22621.819)
• October 25, 2022—KB5018496 (OS Build 22621.755) Preview
• October 18, 2022—KB5019509 (OS Build 22621.675) Out-of-band
• October 11, 2022—KB5018427 (OS Build 22621.674)
• September 30, 2022—KB5017389 (OS Build 22621.608) Preview
• Windows 11, version 21H2
• April 9, 2024—KB5036894 (OS Build 22000.2899)
• March 12, 2024—KB5035854 (OS Build 22000.2836)
• February 13, 2024—KB5034766 (OS Build 22000.2777)
• January 9, 2024—KB5034121 (OS Build 22000.2713)
• December 12, 2023—KB5033369 (OS Build 22000.2652)
• November 14, 2023—KB5032192 (OS Build 22000.2600)
• October 10, 2023—KB5031358 (OS Build 22000.2538)
• September 26, 2023—KB5030301 (OS Build 22000.2482) Preview
• September 12, 2023—KB5030217 (OS Build 22000.2416)
• August 22, 2023—KB5029332 (OS Build 22000.2360) Preview
• August 8, 2023—KB5029253 (OS Build 22000.2295)
• July 25, 2023—KB5028245 (OS Build 22000.2245) Preview
• July 11, 2023—KB5028182 (OS Build 22000.2176)
• June 28, 2023—KB5027292 (OS Build 22000.2124) Preview
• June 13, 2023—KB5027223 (OS Build 22000.2057)
• May 23, 2023—KB5026436 (OS Build 22000.2003) Preview
• May 9, 2023—KB5026368 (OS Build 22000.1936)
• April 25, 2023—KB5025298 (OS Build 22000.1880) Preview
• April 11, 2023—KB5025224 (OS Build 22000.1817)
• March 28, 2023—KB5023774 (OS Build 22000.1761) Preview
• March 14, 2023—KB5023698 (OS Build 22000.1696)
• February 21, 2023—KB5022905 (OS Build 22000.1641) Preview
• February 14, 2023—KB5022836 (OS Build 22000.1574)
• January 19, 2023—KB5019274 (OS Build 22000.1516) Preview
• January 10, 2023—KB5022287 (OS Build 22000.1455)
• December 13, 2022—KB5021234 (OS Build 22000.1335)
• November 15, 2022—KB5019157 (OS Build 22000.1281) Preview
• November 8, 2022—KB5019961 (OS Build 22000.1219)
• October 25, 2022—KB5018483 (OS Build 22000.1165) Preview
• October 17, 2022—KB5020387 (OS Build 22000.1100) Out-of-band
• October 11, 2022—KB5018418 (OS Build 22000.1098)
• September 20, 2022—KB5017383 (OS Build 22000.1042) Preview
• September 13, 2022—KB5017328 (OS Build 22000.978)
• August 25, 2022—KB5016691 (OS Build 22000.918) Preview
• August 9, 2022—KB5016629 (OS Build 22000.856)
• July 21, 2022—KB5015882 (OS Build 22000.832) Preview
• July 12, 2022—KB5015814 (OS Build 22000.795)
• June 23, 2022—KB5014668 (OS Build 22000.778) Preview
• June 20, 2022—KB5016138 (OS Build 22000.740) Out-of-band
• June 14, 2022—KB5014697 (OS Build 22000.739)
• May 24, 2022—KB5014019 (OS Build 22000.708) Preview
• May 10, 2022—KB5013943 (OS Build 22000.675)
• April 25, 2022—KB5012643 (OS Build 22000.652) Preview
• April 12, 2022—KB5012592 (OS Build 22000.613)
• March 28, 2022—KB5011563 (OS Build 22000.593) Preview
• March 8, 2022—KB5011493 (OS Build 22000.556)
• February 15, 2022—KB5010414 (OS Build 22000.527) Preview
• February 8, 2022—KB5010386 (OS Build 22000.493)
• January 25, 2022—KB5008353 (OS Build 22000.469) Preview
• January 17, 2022—KB5010795 (OS Build 22000.438) Out-of-band
• January 11, 2022—KB5009566 (OS Build 22000.434)
• December 14, 2021—KB5008215 (OS Build 22000.376)
• November 22, 2021—KB5007262 (OS Build 22000.348) Preview
• November 9, 2021—KB5007215 (OS Build 22000.318)
• October 21, 2021—KB5006746 (OS Build 22000.282) Preview
• October 12, 2021—KB5006674 (OS Build 22000.258)

Release Date:

OS Builds 22621.3447 and 22631.3447

2/27/24 IMPORTANT: New dates for the end of non-security updates for Windows 11, version 22H2

The new end date is June 24, 2025 for Windows 11, version 22H2 Enterprise and Education editions. Home and Pro editions of version 22H2 will receive non-security preview updates until June, 26, 2024. 

After these dates, only cumulative monthly security updates will continue for the supported editions of Windows 11, version 22H2. The initial date communicated for this change was February 27, 2024. Based on user feedback, this date has been changed so more customers can take advantage of our continuous innovations . 

For information about Windows update terminology, see the article about the  types of Windows updates  and the  monthly quality update types . For an overview of Windows 11, version 23H2, see its update history page . 

Note  Follow  @WindowsUpdate  to find out when new content is published to the Windows release health dashboard.         

Tip:  The content is within collapsible sections. Click or tap the category name to expand the section.

Voice access

New! You can now use voice access with the following languages:

French (France, Canada)

Spanish (Spain, Mexico)

When you turn on voice access for the first time, Windows will ask you to download a speech model. You might not find a speech model that matches your display language. You can still use voice access in English (US). You can always choose a different language from Settings > Language on the voice access bar.

New! You can now use all voice access features on multiple displays. These include number and grid overlays that, in the past, you could only use on the primary display. While you are using the grid overlay on a screen, you can quickly switch to another display. To do that, use the alphabet or NATO phonetic in your command. For example, “B” or “Bravo” are both valid for the display that is assigned that letter.

New! This update introducesvoice shortcuts or custom commands. You can use them to create your own commands in the supported English dialects. To start, say “what can I say” and click the “Voice shortcuts” tab on the left panel. You can also use the command “show voice shortcuts” to open the Voice shortcuts page. Click Create new shortcut . Use your voice or other input to create a command. Give it a name and select one or more actions. After you fill in the necessary information, click Create . Your command is now ready to use. To view all the voice shortcuts you have created, go to the command help page or use the voice command, “show voice shortcuts.”

New! You can now listen to a preview of the ten natural voices before you download them. See the Narrator section of the September 2023 update for the list. These voices use modern , on-device text-to-speech. Once you download them, they work without an internet connection. However, to listen to a preview, you need an internet connection. To add and use one of the natural voices, follow the steps below.

To open Narrator settings, press the WIN+CTRL+N hotkey.

Under Narrator’s voice, select Add , which is next to Add natural voices .

Select the voice you want to install. You can install all voices, but you must install them one at a time.

The preview will play automatically as you browse the list.

If you like the preview, click Download and Install . The new voice downloads and is ready for use in a few minutes, depending on your internet download speed.

In Narrator settings, select your preferred voice from the menu in Narrator’s voice > Choose a voice .

New! This update adds a new keyboard command to move between the images on a screen. Now, you can use the keys G or Shift+G to move forward or backward between images in Scan mode (Narrator key+space bar).

New! This update improves Narrator’s detection of text in images, which includes handwriting. It also improves the descriptions of images. To use this feature, you must have an active internet connection. You must also turn on the setting to get image descriptions in Narrator settings. To try this experience, select an image and press the Narrator key+CTRL+D.

New! In Microsoft Word, Narrator will announce the presence of bookmarks and draft or resolved comments. It also tells you if accessibility suggestions exist when it reads text in the file.

New! You can now use voice access to open applications, dictate text, and interact with elements on the screen. You can also use your voice to command Narrator. For example, you can tell it to, “speak faster,” “read next line,” and so on. To get started, search for “voice access” in Windows search and set it up.

Windows share

New! This update changes the apps that appear in the Windows share window. The account you use to sign in affects the apps that are in “Share using.” For example, if you use a Microsoft account (MSA) to sign in, you will see Microsoft Teams (free). When you use a Microsoft Entra ID account (formerly Azure Active Directory) to sign in, your Microsoft Teams (work or school) contacts show instead.

New! The Windows share window now supports sharing with WhatsApp in the “Share using” section. If you do not have WhatsApp installed, you can install it from the Windows share window.

Nearby Share

New! This update affects how Nearby Share turns on and off. You can use quick settings or the Settings app to turn on Nearby Share. If you do and Wi-Fi and Bluetooth are off, Wi-Fi and Bluetooth will turn on to make Nearby Share work as you expect. If you turn off Wi-Fi or Bluetooth, Nearby Share turns off as well.

New! This update improves Nearby Share transfer speed for users on the same network. Before, users had to be on the same private network. Now, users must be on the same public or private network. You can use quick settings to turn on Nearby Share. Right-click a local file in File Explorer and choose “Share.” Then choose to share to a device listed in Nearby Share in the Windows share window.

New! You can now give your device a more friendly name to identify it when sharing. Go to Settings > System > Nearby sharing . There, you can rename your device.

New! This update helps you to learn about the Cast feature and discover when it is available; see the examples in the list below. To cast means to send content that is on your device’s screen to a nearby PC, TV, or other external displays. This happens wirelessly.

You might often switch between windows to complete a task or use Snap Assist to organize your screen space. When you multitask like this, a notification will suggest that you use Cast.

The Cast flyout menu in quick settings gives you more help to find nearby displays, fix connections, and more.

Snap Layouts

New! This update adds suggestions to   Snap Layouts .  They help you to instantly snap multiple app windows together.

New! You can hover over the minimize or maximize button of an app (WIN+Z) to open the layout box. When you do, app icons will display various layout options. Use them to help you to choose the best layout option.

Windows 365 Boot

New! This update adds dedicated mode for Windows 365 Boot . When you sign in on your company-owned device, doing that also signs you in to your Windows 365 Cloud PC. This occurs using passwordless authentication, like Windows Hello for Business.

New! This new dedicated mode also provides the fast account switcher experience. With it, you can quickly switch profiles and sign in. You can also personalize the experience for your username and password. This includes choosing a custom display picture for the lock screen, storing your username, and more.

New! A company can customize what users see on the screen when they sign in to Windows 365 Boot. In shared mode, you can add company branding from Microsoft Intune.

New! This update adds a fail fast mechanism for Windows 365 Boot. It helps while you are signing in to your Cloud PC. Thesmart logic tells you to address network issues or complete app setup so that Windows 365 Boot does not fail.

New! You can now manage the settings of your physical (local) PC from your Cloud PC. Windows 365 Boot makes it easy to directly access and manage sound, display, and other device settings.

Windows 365 Switch

New! It is now easier for Windows 365 Switch to disconnect. You can use your local PC to disconnect from your Cloud PC. Go to Local PC > Task view . Right-click the Cloud PC button and select Disconnect . This update also adds tooltips to the Cloud PC Start menu. They appear on the options for disconnecting and signing out and help you to learn how each one works.

New! This update adds desktop indicators for Windows 365 Switch.You will see the term “Cloud PC” and “Local PC” on the desktop indicator when you switch between them.

New! The time to connect to Windows 365 Frontline Cloud PC from Windows 365 Switch might be long. While you wait, the screen will show you the connection status and the timeout indicator for the Cloud PC. If there is an error, use the new copy button on the error screen to copy the correlation ID. This helps to address the issue faster.

 Improvements

Note:  To view the list of addressed issues, click or tap the OS name to expand the collapsible section.

Important:  Use EKB  KB5027397  to update to Windows 11, version 23H2.

This security update includes quality improvements. Key changes include: 

This build includes all the improvements in Windows 11, version 22H2.

No additional issues are documented for this release.

This security update includes improvements that were a part of update KB5035942  (released March 26, 2024). When you install this KB:  

This update makes miscellaneous security improvements to internal OS functionality. No additional issues were documented for this release.

If you installed earlier updates, only the new updates contained in this package will be downloaded and installed on your device.

For more information about security vulnerabilities, please refer to the Security Update Guide website and the April 2024 Security Updates .

Windows 11 servicing stack update - 22621.3447 and 22631.3447

This update makes quality improvements to the servicing stack, which is the component that installs Windows updates. Servicing stack updates (SSU) ensure that you have a robust and reliable servicing stack so that your devices can receive and install Microsoft updates.

Known issues in this update

Microsoft is not currently aware of any issues with this update.

How to get this update

Before installing this update

Microsoft combines the latest servicing stack update (SSU) for your operating system with the latest cumulative update (LCU). For general information about SSUs, see Servicing stack updates  and  Servicing Stack Updates (SSU): Frequently Asked Questions . 

Install this update

If you want to remove the LCU

To remove the LCU after installing the combined SSU and LCU package, use the DISM/Remove-Package command line option with the LCU package name as the argument. You can find the package name by using this command: DISM /online /get-packages .

Running Windows Update Standalone Installer ( wusa.exe ) with the /uninstall switch on the combined package will not work because the combined package contains the SSU. You cannot remove the SSU from the system after installation.

File information

For a list of the files that are provided in this update, download the  file information for cumulative update 5036893 . 

For a list of the files that are provided in the servicing stack update, download the  file information for the SSU - versions 22621.3447 and 22631.3447 .  

Need more help?

Want more options.

Explore subscription benefits, browse training courses, learn how to secure your device, and more.

Microsoft 365 subscription benefits

Microsoft 365 training

Microsoft security

Accessibility center

Communities help you ask and answer questions, give feedback, and hear from experts with rich knowledge.

Ask the Microsoft Community

Microsoft Tech Community

Windows Insiders

Microsoft 365 Insiders

Was this information helpful?

Thank you for your feedback.